Skip to content

Tool Spotlight|devvm — secrets stay on the host, the VM never sees the real value

Nov 9, 20261 min
TL;DRdevvm is an MIT-licensed open-source CLI that opens an isolated VM for each project folder, for a coding agent to run inside. Install: brew install devvmhq/tap/devvm, or the official install script. It closes a gap that running an agent directly on your machine leaves open — by default, the VM can reach only allowlisted hosts, and secrets such as your GitHub token never enter the VM at all; a proxy on the host swaps in the real value per request.

Look up & save

Loading dictionary…

🌏 中文版

Tool info

FieldValue
Namedevvm
TypeCLI
GitHubdevvmhq/devvm
Stars400 (at the time of writing, 3 days after launch)
LanguageGo
LicenseMIT
Installcurl -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.

devvm keeps secrets on the host; the VM only ever holds a placeholder
devvm keeps secrets on the host; the VM only ever holds a placeholdera request from the coding agent inside the VM goes through a host-side proxy that swaps in the real secret per the allowlist — the VM itself never holds the real value VM (sandbox) This machine Coding agent devvm proxy secrets stay here Allowed host e.g. github Un-allowed host placeholder real token 403 denied Legend holds secrets allowed host blocked 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

devvmDocker container sandboxRunning directly on the host
Isolation layerVM (its own kernel)Container (shares the host kernel)None
Secrets enter the sandbox❌ only a placeholder; the real value stays in the host proxyUsually the whole env / mounted in—
Default networkAllowlist — only hosts you permitDepends on your Docker setup, often shares the host's networkSame as the host
Isolates multiple agent configs✅ one set per VMYou manage the volumes yourself❌ everything stacked on one machine
Install effortOne install command, devvm doctor for a health checkNeed to know Dockerfiles, volumes, networkingNone

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.

References