io.github.flujo-app/mcp-virtual-computer
OfficialThis server gives an AI agent a persistent Docker virtual computer with a viewable desktop, file system access, command execution, and optional lifecycle/network controls.
Execute shell commands in a persistent Debian Docker container via
terminal_execute, including stdin, args, working directory, and timeout options.Open an interactive virtual computer UI with
computer_ui, returning a browser-accessible URL and MCP resource URI.Manage files using
read_file,write_file,edit_file(exact match or replace all), andlist_directory, all relative to/workspaceor absolute paths.Check runtime status with
runtime_statusto monitor lazy container setup.Control network access dynamically with
set_network_access(enable/disable real network).Toggle desktop environment with
set_desktop_environment(virtual vs real Xfce desktop).When the real desktop is enabled, additionally get screen/accessibility snapshots via
look_at_screen, interact viaclick,type, andscroll, and manage Xfce windows with list/switch/move/maximize/restore/minimize/close tools.Access live resources like
computer://screen/current.pngandcomputer://screen/accessibility.json.Lifecycle controls can be exposed to the model by setting
EXPOSE_LIFECYCLE_TOOLS=true; by default they remain app-only.
Provides a persistent Dockerized computer, allowing command execution in the configured container and UTF-8 file read/write/edit operations.
Enables desktop automation for an Xfce environment, including screen capture, accessibility tree inspection, clicking, typing, scrolling, and window management.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@io.github.flujo-app/mcp-virtual-computer List the files in /workspace and open the first text file"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Virtual Computer
A VM for your agent. And for you.
click the mug to switch between a virtual desktop or a real one
unplug the network cable and cut network access
use the computer screen like a normal screen
copy and paste text between the host browser and the Xfce desktop
model can use terminal, create/read/edit files, see the screen, click, type
little fun thing: if either you or the llm types text, you see that on the keyboard; if one uses the cursor, you see the mouse move on the table.
automatically installs Docker Desktop on Windows for local mode, or flyctl for Fly mode
MCP client example
Local Docker (default)
COMPUTER_ID defaults to agent-workstation when omitted. Set it explicitly to
keep using a named computer or to create a separate one. On a fresh Windows PC,
setup prepares WSL 2 before installing Docker Desktop. Approve the Windows
administrator prompt if shown; if a restart is required, restart Windows, reopen
your MCP client, and retry. See Windows first-use validation.
{
"mcpServers": {
"virtual-computer": {
"command": "uvx",
"args": ["mcp-virtual-computer"],
"env": {
"COMPUTER_ID": "agent-workstation",
"DESKTOP_ENVIRONMENT": "true",
"NETWORK_ACCESS": "true",
"AUTO_INSTALL_DOCKER": "true",
"EXPOSE_LIFECYCLE_TOOLS": "false"
}
}
}
}Fly.io Machine
On a fresh machine, start the MCP once, run the exact flyctl auth login command shown by its error, and restart the MCP client
{
"mcpServers": {
"virtual-computer-fly": {
"command": "uvx",
"args": ["mcp-virtual-computer", "--backend", "fly"],
"env": {
"COMPUTER_ID": "agent-workstation",
"DESKTOP_ENVIRONMENT": "true",
"NETWORK_ACCESS": "true",
"AUTO_INSTALL_FLYCTL": "true",
"EXPOSE_LIFECYCLE_TOOLS": "false"
}
}
}
}Related MCP server: Docker MCP Server
What it exposes
terminal_execute— run a command in the configured Docker container or Fly Machine.read_file— read a UTF-8 text file relative to/workspaceor by absolute path.write_file— atomically write a UTF-8 text file.edit_file— replace one exact text match, or all matches when requested.computer_ui— open or attach the Three.js computer view. Its result includes both the MCP Appresource_uriand a real loopbackurl/dashboard_urlthat opens in an external browser, including for stdio clients.
DESKTOP_ENVIRONMENT defaults to true. With the real desktop enabled it
additionally exposes:
look_at_screen— return the current PNG framebuffer, AT-SPI snapshot, or both.click,type, andscroll— interact by AT-SPI element reference or coordinates.list_windowsandswitch_window— enumerate and activate real Xfce windows.move_window,maximize_window,restore_window,minimize_window, andclose_window— control a selected window by ID, title, or class.computer://screen/current.png— current live framebuffer resource.computer://screen/accessibility.json— Playwright-like AT-SPI tree with element refs, roles, names, actions, focus state, and screen bounds.
The MCP App can always call runtime_status, set_network_access, and set_desktop_environment. Set EXPOSE_LIFECYCLE_TOOLS=true to additionally expose those lifecycle controls to the model; they remain model-hidden by default.
Architecture
Demo: FLUJO
Demo: Claude Desktop
Demo: Goose
Permanent Fly Machine
Fly mode builds the bundled Xfce image with Fly's remote builder and deploys it as one permanent Machine. The root filesystem and /workspace survive MCP restarts, and the Three.js screen uses the same noVNC desktop through Fly's HTTPS/WebSocket proxy.
This is the Xfce framebuffer returned by look_at_screen from a deployed Fly Machine. The same live desktop appears on the rendered computer after computer_ui connects to VNC:

No app name, region, CPU size, memory size, Docker installation, or VNC configuration is required.
The package's MCP Registry declaration, including the docker and fly backend choices, is in server.json. See Fly setup for the complete first-run and authentication flow.
On first use, virtual-computer finds fly/flyctl or downloads the current official release to ~/.fly/bin. It uses a cached fly auth login session or FLY_API_TOKEN, selects the personal organization when available, creates and remembers a generated app, lets Fly choose the closest placement, and defaults to one shared CPU with 1 GB RAM.
Authentication is the only unavoidable account step. On a fresh machine, start the MCP once, run the exact flyctl auth login command shown by its error, and restart the MCP client. The first computer call can take several minutes while Fly remotely builds Xfce. Later starts attach to the same Machine.
Optional overrides remain available as FLY_ORG, FLY_APP_NAME, FLY_REGION, FLY_API_TOKEN, and the --fly-* flags. Set AUTO_INSTALL_FLYCTL=false to require a preinstalled CLI. Deleting or factory-resetting the computer destroys its persistent Fly root filesystem; ordinary MCP shutdown leaves the permanent Machine running. Stop or delete it from Fly when you no longer want it to incur usage.
License and origin
MIT licensed. This project is a persistent-computer fork of Kilntainers with Docker and Fly backends.
Available Tools
9 toolscomputer_uiOpen Virtual ComputerB
Open the interactive Three.js laptop and its computer screen.
Inputs: no named parameters.
edit_fileB
Replace exact UTF-8 text and show it being selected, overwritten, and saved.
Inputs: path (required), new_text (required), old_text (required), replace_all.
list_directoryB
List a Docker directory for the interactive virtual Explorer.
Inputs: path.
read_fileB
Read a UTF-8 text file and show it being opened and scrolled on the virtual computer.
Inputs: path (required).
runtime_statusC
Read genuine lazy container-runtime setup progress.
Inputs: no named parameters.
set_desktop_environmentB
Switch the running computer between virtual and Xfce desktops.
Inputs: enabled (required).
set_network_accessC
Change the running Docker computer's real network access.
Inputs: enabled (required).
terminal_executeA
Execute a shell command in one persistent Debian Docker computer. Commands run in bash. Each call is independent — no state (shell variables, working directory) persists between calls (however filesystem does persist). Use the working_directory parameter or chain commands with && to control execution context.
To write files or pass data without shell escaping, use the stdin parameter (e.g., command="cat > file.txt" with content in stdin). Commands time out after 120 seconds by default (override with the timeout parameter for long-running operations).
Inputs: args, stdin, command, timeout, +1 more.
write_fileA
Write a UTF-8 text file and show it being typed and saved on the virtual computer.
Inputs: path (required), content (required), create_parent_directories.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Most tools target clearly distinct actions: shell execution, file read/write/edit/list, network, desktop, UI, and status. Some overlap exists between terminal_execute and the dedicated file tools, since terminal commands can also create and edit files, but the descriptions clarify their intended specializations.
The majority follow a verb_noun pattern (read_file, write_file, list_directory, edit_file, set_network_access, set_desktop_environment), but terminal_execute, computer_ui, and runtime_status break that pattern with noun-first or noun-only names. The inconsistency is noticeable but not chaotic.
Nine tools is a well-scoped set for a virtual computer MCP server. Each tool addresses a distinct part of the workflow: terminal access, file operations, runtime status, UI launch, and configuration switches, with no obvious bloat.
The tool surface covers the main lifecycle: executing commands, reading/writing/editing/listing files, controlling network and desktop environment, and checking runtime status. Missing file operations like delete or rename are not critical because terminal_execute can handle them, but they are minor gaps in the dedicated file-tool set.
Maintenance
Related MCP Connectors
A private persistent computer: files that survive between runs, a bash shell and JavaScript.
Persistent Linux computers for AI agents: desktop, signed-in browser, vault, apps and shell.
Persistent cloud workspaces for AI agents: run commands, edit files, use git and a browser.
Cloud desktops for AI agents: create a Linux computer, see its screen, click, type and run tasks.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvides isolated Docker environments for code execution, enabling users to create and manage containers, execute multi-language code, save and reproduce development environments, ensuring security and isolation.16-
- AlicenseNot gradedqualityDmaintenanceEnables secure execution of shell commands and file operations within isolated Docker containers. Provides process management, interactive input handling, and comprehensive file system operations for containerized development environments.128 npm6MIT
- AlicenseAqualityDmaintenanceEnables code execution in isolated Docker containers with persistent IPython, Node.js, or R kernels, supporting file import/export and cross-session transfers via MCP tools.6MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to operate a real, private, local Docker-based computer with durable files, terminal access, web research, and a persistent browser or desktop. It supports multiple agent clients via MCP or OpenAPI, with live viewing and human takeover.13Apache 2.0