Simon Willison and Prime Radiant released prototype "external sandbox" servers on November 16–17, 2026 so Claude Code, Codex, and Pi can keep running on your Mac while commands and selected tools execute inside Linux with folder mounts and an optional HTTP allow-list proxy. The pattern is documented on Prime Radiant's blog and Willison's link post.
If you want to try local or cheaper models without granting them full-disk bash, this is a concrete architecture to pilot—not an audited product. Treat it like any other experimental agent harness change: pin versions, read the Claude Code bash-only gap, and keep version control on read-write mounts.
explainx.ai covered the wider GPT-6.2 launch week; this article follows Prime Radiant's protocol, commands, and limitations only.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | Optional—only if you adopt external-sandbox-v86, external-sandbox-container, or external-sandbox-quicksand |
| Is there a fix? | N/A—not a CVE; upgrade by tracking external-sandbox releases |
| Does data leave my machine? | Guest has no network by default; proxy allows listed HTTPS hosts only |
| Biggest Claude gap? | Read/Edit stay on the host; only Bash routes through the sandbox |
| Production safe? | No—blog says not audited for sensitive workloads |
Why external instead of internal sandboxes
Prime Radiant contrasts two designs:
- Run the whole agent inside the sandbox (examples include Fly Sprites and similar "agent-in-VM" stacks).
- Run the agent on the host and send execution to a separate sandbox process on the same machine.
They chose (2) so the agent cannot easily rewrite its own harness, and so the trust boundary stays "everything past this HTTP/WebSocket API"—easier to reason about than co-located agent code inside the guest.
Willison's motivation, echoed in the blog, is weaker or local models: vendor auto-approve modes help, but they still depend on another model judging each action. A kernel-or-VM boundary does not care whether the planner was tricked by prompt injection—it only cares what the guest OS can reach. That lines up with discussions of the lethal trifecta (private data + untrusted content + outbound network) when agents execute fetched instructions—see prompt injection mechanism notes.
Three interchangeable backends
All three servers implement the same localhost API (protocol spec and pytest conformance runner in prime-radiant-inc/external-sandbox):
| Server | Technology | Default port |
|---|---|---|
external-sandbox-v86 | Node.js + v86 WebAssembly x86 emu + Alpine | 8686 |
external-sandbox-container | Python + Apple Containers Linux guest | 8687 |
external-sandbox-quicksand | Python + Microsoft Quicksand + QEMU Alpine wheels | 8688 |
Quick start (v86) from Prime Radiant:
npx --yes external-sandbox-v86 \
--preserve-paths --mount-rw "project=$PWD"
Then Pi with no host fallback tools:
npx --yes @earendil-works/pi-coding-agent \
-e npm:external-sandbox-pi --no-builtin-tools \
--sandbox-url http://127.0.0.1:8686
!uname -a inside Pi should report Linux, not Darwin.
Requirements called out in the blog: Node.js 22.19+ for v86; Apple silicon Mac for container and quicksand paths; first Quicksand run may cache a large Alpine image.
How each agent attaches
Pi — strictest tool routing
The external-sandbox-pi extension replaces bash, read, write, edit, grep, find, ls and routes ! / !! shell shortcuts to the sandbox. --no-builtin-tools ensures Pi cannot fall back to host implementations if the extension fails to load—errors instead of silent host execution.
Codex — exec-server WebSocket
Codex uses an environments.toml entry pointing at ws://127.0.0.1:8686/codex (port varies by backend). Launch with a dedicated CODEX_HOME, codex --sandbox danger-full-access, and flags that disable Codex's inner sandbox so it does not nest conflicting boundaries. Prime Radiant tested codex exec against Codex CLI 0.164.0; the exec-server protocol is experimental.
Claude Code — bash-only prefix
Claude Code hooks CLAUDE_CODE_SHELL_PREFIX to a shared script in the external-sandbox repo so only Bash tool commands forward to the guest. Read and Edit remain on the host—a critical limitation if you assumed "sandboxed Claude Code" means all file access.
Operators must place CLAUDE_CODE_TMPDIR inside a writable mount (.external-sandbox-claude-tmp under the project).
Network proxy, allow lists, and credential replacement
By default, guests have no external network—mitigating exfiltration if code runs inside the guest despite injection.
With --proxy or --proxy-config proxy.json, traffic exits through a host-side HTTP(S) proxy that:
- Enforces per-origin method allow lists (example: GET-only
pypi.organdfiles.pythonhosted.org). - Injects
HTTP_PROXY/HTTPS_PROXYand a custom CA so TLS clients that honor env vars traverse the proxy. - Implements credential replacement: guest sends
Bearer placeholder-github-token; proxy swaps in the host's realGITHUB_TOKENfrom the server environment.
Image: Prime Radiant
The blog warns that allowed hosts could echo credentials back in responses—keep rules narrow.
Image: Prime Radiant
The /proxy UI can edit policy during a live session and shows allowed/denied request logs—useful when debugging why agent-driven pip install failed inside the guest.
What this means if you run AI coding agents
When external sandboxes help
- Prototyping local models or cheaper endpoints where you do not trust auto-approve as much as vendor flagship models.
- Running untrusted repo tasks where Linux-only build artifacts are acceptable (reinstall
node_modulesor.venvinside the guest—macOS-native wheels will not match). - Teaching agents network egress discipline with an explicit allow list instead of full laptop connectivity.
When they do not replace your existing controls
- Claude Code Read/Edit bypass means prompt injection in repo files can still touch host paths Claude reads directly—pair sandboxes with workspace policy and human review, not sandbox alone.
- Read-write mounts can still be wiped or encrypted by guest code; the blog recommends git and read-only mounts where possible—same lesson as Claude Code workspace TOCTOU issues.
- Supply-chain installs inside the guest (
pip,npm) still pull PyPI malware such as agent-framework 1.26.1; the sandbox limits host damage, not bad packages inside the guest.
Practical checklist
- Start with read-only mounts for everything except a single
projectdirectory under git. - Enable proxy allow lists before granting any network—default-deny matches Prime Radiant's lethal trifecta mitigation story.
- For Claude Code, assume host Read/Edit exposure; do not store production secrets in files the agent can open natively.
- Pin
npx --yespackage versions in runbooks so agents do not pull drifting sandbox servers. - Log proxy denials when debugging agent "can't reach API" failures—often the model tried a host you did not allow.
How Beam handles this
Beam is local, on-device observability and hook-based policy for Claude Code and Codex on the host where the harness runs: it records PreToolUse proposals, can deny matching actions in enforce mode (when cached policy is present), and scans skills/MCP configs with heuristics before execution. It is not a VM sandbox and does not implement Prime Radiant's guest Linux boundary.
Concrete split:
- External sandbox limits what successful bash/tool calls can do inside the guest and optionally network egress.
- Beam limits what the host harness attempts—destructive shell patterns, credential reads in transcripts, suspicious skill installs—and keeps redacted evidence under your user account.
Use both when you run Claude Code with bash prefixing: Beam still sees Read/Edit on the host, while the sandbox shrinks command effects. Beam's deny is heuristic and hook-based, not kernel-enforced; missing policy cache is fail-open per Beam agent-cli policies.
Protocol, conformance, and building another backend
The external-sandbox repository separates protocol from implementation:
- A specification for HTTP/WebSocket command and file operations shared by v86, Apple Containers, and Quicksand servers.
- A pytest conformance runner so new backends (Firecracker, cloud VMs, corporate VDI) can prove compatibility before agents rely on them.
That design matters for platform teams: you can standardize on one proxy policy file format (JSON allow lists plus credential replacement rules) while swapping isolation technology under performance or compliance constraints.
Prime Radiant documents example proxy.json entries that allow read-only PyPI fetches while injecting a real GITHUB_TOKEN only at the proxy—guest code sees placeholder-github-token. The blog warns that responses from allowed origins could leak secrets back to the guest, so narrow paths and methods aggressively.
Codex configuration details worth copying
The blog's environments.toml pattern uses a dedicated CODEX_HOME so your daily Codex credentials do not collide with sandbox experiments. Flags such as features.shell_snapshot=false and features.unified_exec_tty=false matter because Codex's inner sandbox must be disabled to avoid double isolation that breaks streaming or TTY expectations.
Document these flags in your internal agent runbook the same way you document beam sync for policy version—future Codex CLI bumps may change experimental exec-server behavior.
Linux-vs-macOS dependency friction
Because guests run Alpine Linux, a project whose node_modules or Python wheels were compiled on macOS may fail inside the sandbox until dependencies are rebuilt inside the guest. Agents will often try to "fix" this by wiping directories on the host unless you constrain mounts—another reason to keep git as the recovery layer on read-write trees.
Limitations Prime Radiant states plainly
The blog's "let us know what you think" section is explicit:
- Prototypes are not audited for sensitive workloads.
- Read-write mounts can still destroy project data.
- Claude Code Read/Edit on host bypasses guest boundaries.
- Codex exec-server is experimental; version 0.164.0 is what their automated tests targeted.
None of these caveats are hideable if you evaluate sandboxes for regulated code—pair prototypes with vendor sandboxes (Claude Code permissions, Codex network settings) and local policy rather than replacing them.
Willison also ties the effort to running untrusted code safely while experimenting with local models—a niche where vendor auto-approve features may be thinner. External sandboxes are a lab harness, not a compliance control, until Prime Radiant or your platform team completes independent review.
What developers are saying
Simon Willison's link post tags sandboxing, coding-agents, and claude-code; substantive technical debate at publish time lived primarily in Prime Radiant's long-form blog and the external-sandbox GitHub issues—no single HN thread was attached to this candidate feed item.
Frequently asked questions
See the front-matter FAQ for version-specific commands. Prime Radiant asks for feedback via GitHub issues on external-sandbox.
Related reading
- Introducing Beam: local-first agent security
- MCP security practical guide — tool and server boundaries
- Prompt injection and capability security
- Claude Code Edit tool TOCTOU outside workspace
- Microsoft agent-framework PyPI stealer (Nov 17)
- Simon Willison llm 0.37.3 tool-call fixes — adjacent local agent plumbing
- Prime Radiant external sandboxes blog and protocol repo
Prototype commands and ports reflect Prime Radiant's November 17, 2026 blog. Re-read upstream READMEs before baking into production runbooks.

