Skip to main content
Glama

terrarium

Real, disposable computers in seconds, for you and your AI agent.

Fork a fresh Windows or Linux machine, use it, break it, reset it to spotless in the time it takes to read this.

CI Go License

one command, a real Windows machine

Get started

You need an x64 Windows or Linux host with VirtualBox 7.x. Do not have it yet?

winget install Oracle.VirtualBox

On Linux, install the virtualbox-7.x package from Oracle's repository; see Linux hosts for what differs.

With Claude Code

One command. npx fetches the package with the terrarium binary inside, so there is nothing else to install:

claude mcp add -s user terrarium -- npx -y terrarium-mcp mcp

Open a new Claude Code session and ask for a machine:

Fork a fresh debian-12 machine, run uname -a in it, then delete it.

The agent checks the host, downloads the image, builds it, forks it, and reports back. Linux images download themselves; a Windows machine needs an installation ISO from you, once - see Images.

From the command line

npm i -g terrarium-mcp

Then:

$ terrarium doctor                 # can it talk to VirtualBox?
$ terrarium get debian-12          # download the image, boot it once, snapshot it (~1 min)
$ terrarium fork debian-12 t1      # a throwaway machine, SSH-ready in ~20s
$ terrarium exec t1 -- uname -a
$ terrarium revert t1              # back to clean in seconds

ssh t1 opens a shell, rm t1 deletes the machine, down and start park and wake it. fork --ttl 2h marks an env to expire and terrarium gc removes the expired ones.

No Node? Install covers Scoop, Go, and other MCP clients.

Related MCP server: windows98-mcp

Why

Containers are the right way to ship a Linux service and the wrong way to test a whole system: every container borrows the host's kernel, so a build that passes in one can still fail on real hardware. VMs have always fixed that. What they lacked was the container workflow: image, run, throw away.

terrarium is that workflow on top of the VirtualBox you already have. Fork a golden image in a tenth of a second. Wreck the fork and put it back in seconds. Do it from the command line, or hand the same power to an AI agent over MCP. It ships no virtualization code, wraps VBoxManage, and never touches a VM it did not create.

What people use it for:

  • Set the goal, walk away. Give an agent a real disposable machine over MCP and a goal; it builds, fails, reverts, and retries on its own, unsupervised, all the way to installing something end to end - and the task can involve the screen, not just the command line.

  • Let an agent test an install end to end on a real machine, from first boot to a working app.

  • Let an agent write a guide or reproduce a bug and hand back a step-by-step screenshot trail or a GIF, exactly like the recordings in this README.

  • Isolated, disposable, real. Do sensitive or risky work on a machine you can throw away, so it never touches your own.

  • Clean-machine testing. Run your installer or build on a machine that has never seen your dev setup, and "works on my machine" stops being an argument.

Contents

Features

Every recording below is real: real commands, real screenshots read from the guest's video memory, and a timer that shows real wall-clock seconds. docs/demo explains how they are made.

Fork Windows: a desktop from cold in ~40s

fork a Windows machine

Fork Linux: SSH answering in ~20s

fork a Linux machine

Brick it, then revert it: clean again in 13s

break a machine past boot, then revert it

Claude wins Minesweeper on XP: no SSH, nothing installed

Claude wins Minesweeper on a Windows XP fork through the hypervisor

How it compares

terrarium

Docker

VirtualBox

Vagrant

Hyper-V

Multipass

WSL2

a real, whole machine (its own kernel)

✅

❌

✅

✅

✅

✅

❌

Windows guests

✅

❌

✅

✅

✅

❌

❌

legacy guests (XP era)

✅

❌

✅

❌

❌

❌

❌

new machine in one command, seconds

✅

✅

❌

❌

❌

❌

❌

reset to clean state in seconds

✅

✅

❌

❌

❌

❌

❌

environment shared as a small text file

✅

✅

❌

✅

❌

❌

❌

drives GUI-only guests (screen, mouse)

✅

❌

❌

❌

❌

❌

❌

AI agent tools built in (MCP)

✅

❌

❌

❌

❌

❌

❌

production workloads

❌

✅

❌

❌

✅

❌

❌

runs on any host OS

❌

✅

✅

✅

❌

✅

❌

If your work fits in a container, use Docker. When it needs a real, whole machine you can break and un-break - and the last two rows are prices you can pay - the first column is the point of this project. VirtualBox gets its own column on purpose: terrarium runs on it, so the green half of that column is the engine, and the red half is what this project adds.

A dev environment per project

# terrarium.yaml, committed in your repo
image: ubuntu-24.04
cpus: 4
memory: 4096

terrarium up forks an env named after the project, shares the project folder at /work in the guest, and adds it to ~/.ssh/config, so ssh <project> works and VS Code Remote-SSH sees it one click away. down parks it, up brings it back, revert resets it.

Everyday commands

terrarium ls lists the machines with their guest type, and terrarium info <name> reports one in full - architecture, hardware, snapshot, credentials. terrarium cp ./app.tar t1:/tmp/ moves files in or out over the env's own SSH. terrarium create s11 --iso suse.iso --ostype OpenSUSE_64 installs an OS by hand from an ISO, see Images.

  • exec <env> --shell powershell|cmd|sh -- <command...> runs the command under that shell instead of the one the guest's sshd would pick.

  • exec <env> --stdin reads a whole script from stdin and runs it in the guest, so nothing in it needs escaping.

  • exec <env> --kill-on-timeout kills the command and its children in the guest when the timeout fires, instead of leaving it running unwatched.

  • exec <env> --desktop runs it in the logged-in session of a Windows guest, so a window or a dialog it opens is on the screen screenshot shows.

Your AI agent gets real computers

Setup is one command - see Get started. The same binary is an MCP server: every command above as a tool, plus screenshot, click, scroll, type, and keys - screen, mouse and keyboard injected through the hypervisor, so nothing is installed in the guest and no network or guest additions are needed. That is how an agent drives an installer, a login screen, or an OS too old for SSH - exactly what the Minesweeper recording above shows. On connect the server tells the agent to run doctor first and report what is missing instead of flailing.

  • "Fork a clean env, build the project in it, tell me what the README missed."

  • "Install our app on the Windows env and screenshot each step."

For Windows guests with SSH, terrarium rdp opens a full desktop already logged in: mstsc on a Windows host, FreeRDP on Linux.

Install

Get started has the two fast paths. Everything else about installing is here. terrarium is a single binary for Windows and Linux; VirtualBox 7.x is the only thing it needs on the host.

Scoop (Windows, no Node needed)

If you do not have Scoop yet, from a normal (non-admin) PowerShell:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

Then:

scoop bucket add terrarium https://github.com/chryaner/terrarium
scoop install terrarium

If you installed Scoop in this same window, its shims are not on the current shell's PATH yet, so terrarium will not be found. Open a new terminal, or refresh PATH in place:

$env:Path = [Environment]::GetEnvironmentVariable('Path','User') + ';' + [Environment]::GetEnvironmentVariable('Path','Machine')

The Scoop binary is the same MCP server: claude mcp add -s user terrarium -- terrarium mcp.

Release archive (Linux, no Node needed)

Each release carries a terrarium_<version>_linux_amd64.tar.gz with the binary inside; put it anywhere on your PATH.

Go

go install github.com/chryaner/terrarium/cmd/terrarium@latest

Run it without installing

npx runs the CLI straight from the package cache: npx -y terrarium-mcp doctor.

Other MCP clients

Any client that launches stdio servers takes the same command. In JSON form:

{
  "mcpServers": {
    "terrarium": {
      "command": "npx",
      "args": ["-y", "terrarium-mcp", "mcp"]
    }
  }
}

Updating

npm update -g terrarium-mcp or scoop update terrarium. npx -y picks up new versions on its own. terrarium version prints what you have.

Linux hosts

Everything works the same, with these differences:

  • Data directory. State, images, keys, local recipes and ISOs live in $XDG_DATA_HOME/terrarium, which is ~/.local/share/terrarium by default. On Windows it is %LOCALAPPDATA%\terrarium. terrarium doctor prints it.

  • Mouse. VBoxManage has no mouse command, and the COM API terrarium uses on Windows does not exist on Linux, so click and scroll go through VirtualBox's web service. terrarium starts its own vboxwebsrv on first use: bound to 127.0.0.1:42199, with VBoxAuthSimple and a password generated into the data directory, so other users on the machine cannot drive your VMs through it, and it refuses to send that password to a port another user holds. It keeps running after the command, like VBoxSVC, and pkill -f 'vboxwebsrv.*--port 42199' stops it. The only global change is the extradata key VBoxAuthSimple/users/terrarium, which holds the password's hash.

  • RDP. terrarium rdp opens xfreerdp3, xfreerdp or sdl-freerdp3, whichever is installed, and passes the password on stdin rather than the command line. With no graphical session it prints the .rdp file instead.

  • Kernel modules. doctor checks that vboxdrv is loaded, and warns when KVM is, because KVM can hold the CPU's virtualization extensions and make every VM fail to start.

  • Not in WSL2 or a container. VirtualBox needs its kernel driver and the CPU's virtualization extensions, which neither provides. Run terrarium on the Windows side instead.

git-bash

MSYS rewrites absolute paths in arguments (/etc/hosts becomes C:/Program Files/Git/etc/hosts) before terrarium ever sees them. Prefix the command with MSYS_NO_PATHCONV=1 to stop it.

How fast

operation

measured

fork a golden (linked clone)

0.1 s

Linux fork to SSH answering (cold)

~20 s

Windows fork to a usable desktop (cold)

~40 s

revert to clean state (RAM resume)

8-11 s

snapshot a running machine (RAM)

4 s

disk per fork

28-48 MB

build a Linux golden from scratch

~40 s

Measured on a desktop (i9-14900K, NVMe, VirtualBox 7.2). Your numbers will differ; the shape will not. Forks are linked clones: they share the golden's disk, which is why cloning costs a tenth of a second and megabytes, not minutes and gigabytes.

Images

A golden is the vendor's own published image plus a few lines of YAML, so the bytes always come from the distribution that maintains them. Adding an image is a pull request with one file.

Linux: downloaded for you

terrarium get <name> downloads the official cloud image, seeds it with a generated SSH key, boots it once, and snapshots it. About a minute each.

recipe

downloads from

ubuntu-24.04

cloud-images.ubuntu.com

ubuntu-22.04

cloud-images.ubuntu.com

debian-12

cloud.debian.org

debian-13

cloud.debian.org

alma-9

repo.almalinux.org

rocky-9

dl.rockylinux.org

fedora-44

fedoraproject.org

opensuse-16.0

download.opensuse.org

Windows: bring your own ISO

There is no Windows cloud image and Microsoft's media cannot be redistributed, so you download the ISO once and terrarium runs the real installer unattended:

  1. Download the installation ISO from Microsoft.

  2. Save it in the isos folder of terrarium's data directory (%LOCALAPPDATA%\terrarium\isos\ on Windows, ~/.local/share/terrarium/isos/ on Linux), named for the recipe: win10.iso, winxp.iso.

  3. terrarium get win10. Fully unattended: about ten minutes for win10, seven for XP.

A win10 golden comes out key-based like the Linux ones: the install generates an ed25519 pair, puts the public half in the guest and records the private one, so ssh and scp from the generated ~/.ssh/config entry never prompt. Its SSH sessions land in PowerShell, so exec quotes for PowerShell rather than cmd.exe. A golden built by an older terrarium keeps its password and its cmd shell; re-run terrarium get win10 --force to rebuild it.

win10 and winxp ship today. XP predates OpenSSH, so its forks are driven through screenshot, click, type and keys rather than exec, and its recipe needs a product key you supply in a local override. Recipe details, private mirrors and the unattended-install internals are in docs/DESIGN.md.

adopt --transport guestcontrol --user <u> --password <pw> reaches a Windows with no SSH server through VirtualBox Guest Additions instead, if they are installed in it, and exec, cp and the MCP tools then work on its forks.

Install any OS from an ISO by hand

Some systems have neither a cloud image nor an installer that can be answered in advance. terrarium create <name> --iso <path> --ostype <type> builds a blank machine with the ISO in its drive and boots it, and you answer the installer through screenshot, type, keys and click - revert puts the blank disk back if you want to start over. The machine has no credentials until the install is done: promote it into a golden, then adopt that golden with the user and password you created inside it.

Layer your own

A recipe can build on another image instead of on media: from names the base, setup runs commands in a fork of it, and the result is flattened into a new golden. The YAML file is the shareable artifact - a teammate with the same file builds an equivalent machine from their own base, so no disk image (and no Windows license) ever changes hands.

# <data directory>/recipes/team-dev.yaml
name: team-dev
from: debian-12
setup:
  - sudo apt-get update
  - sudo apt-get install -y git build-essential

terrarium get team-dev builds it in seconds on top of an existing base. For state you made by hand rather than by script, terrarium promote <env> <name> flattens a configured env into a golden directly. terrarium rm --golden <name> removes an image you are done with.

Machines you already have

terrarium adopt <vm> records a VirtualBox VM you built yourself as a golden, without modifying it. terrarium import <file.ova> --name <golden> does the same for an appliance file: it imports and snapshots it, and seeds nothing, so an export that predates cloud-init imports instead of hanging.

Neither needs credentials. When you do not know the login yet, adopt or import without one, fork it, and drive the fork through the console:

$ terrarium import centos6.ova --name centos6
$ terrarium fork centos6 probe
$ terrarium screenshot probe          # read the login prompt
$ terrarium type probe root --enter   # try one
$ terrarium screenshot probe          # did it take?
$ terrarium adopt trr-golden-centos6 --name centos6 --user root --password <pw>

Re-running adopt updates the record, so the last line is how a credentialless golden becomes one exec and ssh work against. terrarium info <name> reports what a golden or env actually is - guest type, architecture, hardware, snapshot and which credentials are recorded - and screenshot works on any running machine, including a golden or a VM terrarium does not manage.

What it is not

  • Not on every host. The host must be x64 Windows or Linux with VirtualBox; macOS has had no testing. Every hypervisor call sits behind one package by design, so a QEMU or Hyper-V driver is a planned door, not a promise.

  • Not for production. Forks are cattle for development and testing.

  • Not a secrets manager. A Windows golden's password is stored in plain text locally and is briefly visible on the VBoxManage command line during the install. Use a throwaway password.

License

Apache-2.0. Recipes, issues and field reports welcome, the most useful contribution is a recipe for an image people actually use.

Available Tools

24 tools
doctorA

Check that this machine can run terrarium at all: VirtualBox present and responding, state directory writable, SSH client available. Call this once before anything else. Cheap and safe to call at any time. If it reports ok:false, report the failing check and its fix to the user rather than working around it.

Returns: ok, checks

env_clickA

Click the environment's screen at a pixel position, 0-based, exactly as seen in env_screenshot. Left button unless button says otherwise; double for a double-click. Like env_screenshot it goes through the hypervisor and needs nothing of the guest, but the click lands wherever the pixel says, so screenshot first and aim. The environment must be running.

Inputs: x (required), y (required), name (required), button, +1 more. Returns: log, name

env_createA

Create a blank environment with an installation ISO in its DVD drive and boot it, for an OS that has no recipe and no unattended installer - an old distribution, or one whose installer has to be answered by hand. The boot order is disk first, DVD second, so the installer runs while the disk is blank and the installed system boots itself afterwards. The result has no golden image and therefore no credentials: env_exec will not work on it. Drive the installer with env_screenshot, env_type, env_keys and env_click, and note that env_revert puts the blank disk back and restarts the install. When the OS is up, env_promote turns it into a golden - and golden_adopt then records the account created inside it. iso_path is a path on this host, where the server runs.

Inputs: name (required), ostype (required), iso_path (required), cpus, +2 more. Returns: env, log

env_downA

Shut an environment down cleanly, keeping its disk and its place in the environment list. env_start brings it back with everything intact.

Inputs: name (required). Returns: log, name

env_execA

Run a shell command inside an environment and return its exit code and output. The command is one shell string: pipes, redirects, globs and quoting are interpreted by the guest shell, unlike the CLI's terrarium exec, which passes its arguments literally. Which shell that is: /bin/sh on Linux guests; on a Windows guest, the shell recorded for its golden, which is PowerShell for a golden terrarium built and cmd.exe for an older or adopted one, unless terrarium adopt --shell said otherwise. Pass shell (powershell, cmd or sh) to run under a different one, and script instead of command for anything multi-line or heavily quoted - a script reaches the shell on stdin, so nothing in it is re-parsed on the way. The environment must be running. Commands run as a user with passwordless sudo, so this can change or destroy anything inside the guest - the host is not affected. A command that outruns timeout_sec is killed in the guest, with its child processes, and the error says what was killed: nothing is left running where you cannot see it. On a Windows guest an ordinary command runs in session 0, which has no screen: if it opens a window or a dialog it waits there forever and env_screenshot shows nothing. Set desktop to run it in the session a user is logged into instead, where env_screenshot can see what it wants. Only works when the environment's golden has SSH credentials; without them, use env_screenshot, env_type, env_keys and env_click.

Inputs: name (required), shell, script, command, +2 more. Returns: output, exit_code

env_forkA

Create a new environment from a golden image and boot it. Takes under a minute and costs tens of MB of disk. The environment is disposable: anything done inside it is lost on env_rm, and env_revert rewinds it to the state it had right after this call. If the golden has no SSH credentials recorded - env_list shows an empty ssh_user, which is normal for an old or GUI-only system - env_exec will not work on the result. Drive it with env_screenshot, env_type, env_keys and env_click instead.

Inputs: name (required), golden (required), cpus, memory_mb, +2 more. Returns: env, log

env_gcA

Remove environments that have outlived the TTL set at fork time (ttl_seconds), plus any whose VM has vanished from VirtualBox. Environments forked without a TTL are never removed by age. Pass dry_run to see what would go without removing it. Good to call before finishing a session so short-lived envs do not pile up.

Inputs: dry_run. Returns: dry_run, removed

env_keysA

Press keys and chords in the environment that env_type cannot express. Each entry in the list is one keystroke, and chords land as chords. The environment must be running. Valid key names: alt-f4, alt-tab, backspace, ctrl-a..ctrl-z, ctrl-alt-del, delete, down, end, enter, esc, f1, f10, f11, f12, f2, f3, f4, f5, f6, f7, f8, f9, home, left, pgdn, pgup, right, space, tab, up, win (the ctrl run is literal: ctrl-x, ctrl-d and so on). For the mouse, use env_click and env_scroll.

Inputs: keys (required), name (required). Returns: log, name

env_listA

List the golden images available to fork from and the environments that exist, with their SSH ports and whether each is currently running. Read-only.

Returns: envs, goldens

env_promoteA

Flatten an environment's current state into a new golden image that env_fork can use, so a machine configured during this session becomes a reusable fork source. A full disk copy: takes minutes and the disk of a golden, and afterwards depends on nothing. The environment is shut down first and left in place; remove it with env_rm if it is no longer needed once promoted. Promote only when the user wants the machine kept: the result is durable and only the user can remove it.

Inputs: name (required), image (required). Returns: log, golden

env_pullA

Copy a file or directory out of an environment onto this host, over the same connection env_exec uses. guest_path is inside the guest and always uses forward slashes, Windows guests included; local_path is on the host, where this server runs, and its missing parent directories are created. Set recursive for a directory. Needs the same credentials env_exec needs.

Inputs: name (required), guest_path (required), local_path (required), recursive. Returns: name, guest_path, local_path

env_pushA

Copy a file or directory from this host into an environment, over the same connection env_exec uses. local_path is on the host, where this server runs; guest_path is inside the guest and always uses forward slashes, Windows guests included (C:/Users/terrarium/setup.exe). Missing parent directories in the guest are created. Set recursive for a directory. Needs the same credentials env_exec needs.

Inputs: name (required), guest_path (required), local_path (required), recursive. Returns: name, guest_path, local_path

env_restoreA

Rewind an environment to a named snapshot taken with env_snapshot. Everything done since that snapshot is lost. Use env_revert instead to go back to the environment's original clean state.

Inputs: name (required), snap (required). Returns: log, name

env_revertA

Discard everything done inside an environment since it was forked, returning it to its clean snapshot. Files written in the guest are lost. Takes seconds, because the snapshot includes RAM and the machine resumes rather than reboots.

Inputs: name (required). Returns: log, name

env_rmA

Destroy an environment and delete its disks. Everything inside it is gone for good. The golden image it was forked from is untouched.

Inputs: name (required). Returns: log, name

env_screenshotA

Capture a running machine's screen and return it as an image. This is how to see a guest that has no SSH - it needs nothing of the guest, not even a network. The name can be an environment, a golden image, or any VirtualBox VM by name: reading a screen changes nothing, so this one is safe to point at a machine terrarium does not manage. The input tools (env_type, env_keys, env_click, env_scroll) are environments only. The machine must be running. The screen lags behind keystrokes, so after env_type or env_keys take a fresh screenshot to see what actually happened.

Inputs: name (required). Returns: width, height

env_scrollA

Scroll the environment's mouse wheel: the pointer moves to the given pixel position, then the wheel turns there. Positive clicks scroll down, negative up. The environment must be running.

Inputs: x (required), y (required), name (required), clicks (required). Returns: log, name

env_snapshotA

Take a named snapshot of an environment, to come back to later with env_restore. A running environment has its RAM captured too, so restoring resumes rather than reboots. Cheap: seconds, and only the changed disk blocks.

Inputs: name (required), snap (required). Returns: log, name

env_startA

Boot a stopped environment and wait until SSH answers. Does nothing if it is already running. Fails if no environment by that name exists - use env_fork to create one.

Inputs: name (required). Returns: env, log

env_typeA

Type text into the environment's keyboard, as if a person were at it - the keystrokes go wherever the guest's focus happens to be, so check with env_screenshot first. Environments only: to type into a golden image, env_fork it and type into the fork. The environment must be running. Takes effect a moment after the call returns.

Inputs: name (required), text (required), press_enter. Returns: log, name

golden_adoptA

Record a VirtualBox VM that already exists on this machine as a golden image env_fork can use. The VM itself is not modified unless take_snapshot is set. Re-running it updates the record, which is how credentials are added later: adopt a machine with no user or password, fork it, read its login prompt with env_screenshot, try a guess with env_type, then adopt again with what worked. Records nothing about the guest that was not observed - never invent a user or password here.

Inputs: vm (required), key, user, image, +5 more. Returns: log, golden

golden_getA

Build a golden image from a recipe so environments can be forked from it. Slow and bandwidth-heavy: downloads roughly 500 MB the first time, then imports the appliance, boots it once for cloud-init, shuts it down and snapshots it. Takes minutes, and a Windows image takes closer to an hour because it runs a real installer. A recipe with from instead builds on an existing golden: it forks the base, runs the recipe's setup commands in the fork, and flattens the result into the new golden. Use recipe_list for the names that work here. Fails if the golden already exists - rebuilding one is a decision for the human.

Inputs: image (required), cpus, memory_mb. Returns: log, golden

golden_importA

Register an .ova or .ovf appliance file already on this machine as a golden image. Unlike golden_get there is no recipe and no download, and nothing is seeded: an appliance exported from somewhere else has no cloud-init to wait for. The VM is imported, snapshotted where it stands and recorded as a golden env_fork can use. Credentials are optional - import without them, then work the login out through env_fork, env_screenshot and env_type, and record it with golden_adopt. Creates something durable that only the user can remove, so do it when the task asks for it.

Inputs: image (required), ova_path (required), key, user, +1 more. Returns: log, golden

recipe_listA

List the images that CAN be built into golden images with golden_get. This is the catalogue of what is available to build; env_list reports what has actually been built and what can be forked right now. Read-only.

Returns: recipes

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 24 tools

    Disambiguation5/5

    Every tool maps to a distinct resource and action: golden creation (golden_get/import/adopt), environment lifecycle (fork/create/start/down/rm), state management (snapshot/restore/revert), and interaction (screenshot/type/keys/click/scroll/exec/pull/push). The closest pair, env_restore and env_revert, is clearly differentiated by snapshot vs. original state.

    Naming Consistency4/5

    The env_* and golden_* prefixes give a strong, predictable grouping, and most names follow an action-style pattern (env_start, env_fork, env_push). Minor deviations like env_keys, env_screenshot, and the unprefixed doctor/recipe_list keep it from being perfectly uniform.

    Tool Count3/5

    At 24 tools, this sits in the heavy 16–25 range, though the VM lifecycle scope is broad enough that each tool has a distinct purpose. It feels borderline rather than bloated or redundant.

    Completeness4/5

    The set covers the full environment lifecycle: golden image creation/import, forking, power management, screenshots, keystrokes, command execution, file transfer, snapshots, promotion, and cleanup. Minor gaps exist—no golden deletion tool and no way to list snapshots—but core workflows have no dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      A
      quality
      B
      maintenance
      A virtual Linux desktop as an MCP server, shipped in Docker. Agents drive screen, mouse, keyboard across any GUI — browsers, IDEs, office suites, Wine/Windows apps, legacy software — many in parallel.
      12
      159
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Provider-neutral MCP server for managing VirtualBox, VMware Fusion, and VMware Workstation, offering tools for VM lifecycle, configuration, snapshots, guest operations, networking, and artifact resolution.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables LLMs to remotely control VirtualBox VMs and Playwright browsers on Windows, including VM lifecycle actions, in-guest commands, browser automation, window management, and service monitoring via REST API and MCP.
      MIT