🌏 中文版
Tool info
| Field | Value |
|---|---|
| Name | devvm |
| Type | CLI |
| GitHub | devvmhq/devvm |
| Stars | 400 (at the time of writing, 3 days after launch) |
| Language | Go |
| License | MIT |
| Install | curl -fsSL https://github.com/devvmhq/devvm/releases/latest/download/install.sh | bash |
What problem it solves
Run a coding agent directly on your own machine, and it can technically reach more than the project folder: .ssh, .aws, browser cookies, services on your internal network, and any token you've ever pasted into a terminal. A common fix is a Docker container, but a container shares the host's kernel — once a command escapes that kernel layer, the isolation is gone. That's not a hypothetical: a PWN Research post published 2026-11-07 demonstrated escaping a Firecracker microVM and getting root code execution on the host.
devvm picks a different isolation layer: every project folder gets its own real virtual machine, run on Lima over QEMU rather than a container, and the VM mounts only that one project folder. New VMs default to the "allowlist" network tier, reaching only the hosts you've explicitly permitted. Secrets like your GitHub token or Claude Code's login never enter the VM at all — the VM only ever gets a placeholder string, and a proxy on the host swaps in the real value as it forwards the request. If something in the VM tries to bypass that proxy and connect directly, all it can send out is the placeholder, and the real host still rejects it. Claude Code, Codex, opencode, and pi each keep their own settings inside the VM, so none of it touches what's already installed on your host.
It's a good fit when you want an agent to run unattended for a while, touching the filesystem or installing packages, without re-assessing every time whether this run might touch something it shouldn't see; when you run several coding agents and don't want their configs fighting for the same install on one machine; or when you want the VM to share the project folder with your editor directly, instead of a commit-and-push round trip to see the result. It's a poor fit for a single, one-off shell command — spinning up a VM has a few seconds of startup cost — and for Windows: the project's own testing currently covers only macOS (Apple silicon) and Linux (arm64/x86_64).
Getting started
Install
# macOS (also installs Lima)
brew trust --formula devvmhq/tap/devvm
brew install devvmhq/tap/devvm
# Linux (also works on macOS; asks before installing Lima, QEMU, or /dev/kvm access)
curl -fsSL https://github.com/devvmhq/devvm/releases/latest/download/install.sh | bash
# Check what's missing
devvm doctor
Basic usage
cd ~/some-project
devvm
# First run asks for the VM's size, toolchains, and network tier (default: allowlist)
# Confirm, and you land in the VM's shell, prompt prefixed with (devvm)
(devvm) $ claude
Advanced usage
# Give the VM its own clone instead of mounting your working tree directly
devvm --clone
# Once the agent's done, fetch its branch back to this machine and review before merging
git fetch devvm
git log -p main..devvm/main
# See what the VM's proxy has blocked lately
devvm network log --blocked
Compared to existing options
| devvm | Docker container sandbox | Running directly on the host | |
|---|---|---|---|
| Isolation layer | VM (its own kernel) | Container (shares the host kernel) | None |
| Secrets enter the sandbox | ❌ only a placeholder; the real value stays in the host proxy | Usually the whole env / mounted in | — |
| Default network | Allowlist — only hosts you permit | Depends on your Docker setup, often shares the host's network | Same as the host |
| Isolates multiple agent configs | ✅ one set per VM | You manage the volumes yourself | ❌ everything stacked on one machine |
| Install effort | One install command, devvm doctor for a health check | Need to know Dockerfiles, volumes, networking | None |
Watch out for
- Testing currently covers only macOS (Apple silicon) and Linux (arm64/x86_64). The README states Intel Macs aren't supported yet, and doesn't mention Windows at all — it isn't in scope today.
- A VM costs more than a container. The first VM needs a few minutes to build its base image and 8GB of free disk space; the project recommends at least 8GB of RAM and 4 CPUs, more than a bare container typically needs.
- The allowlist only covers the sources devvm already knows about. The first request to a legitimate service it has no built-in rule for — an internal package registry, say — gets a 403, and you add the rule yourself with
devvm network allow; it isn't open-by-default once installed.
Today's takeaway
Most of the past year's talk about agent security has stopped at "should I add a sandbox," but the Firecracker-escape writeup from 2026-11-07 is a reminder that even microVM-level isolation isn't an absolute guarantee. devvm's approach is more modest about that: it doesn't claim to be unbreakable. Instead, it structurally removes secrets — the one category of thing you can't take back once it leaks — from the VM entirely, so the real token string never passes through it in the first place. Even if the VM were fully compromised, the most it could steal is a placeholder. That's a "shrink the blast radius" design, not a "assume the wall holds" one, and it's worth borrowing for any setup where an agent runs unattended for a while.