Prime Radiant released a family of external sandbox servers on November 17, 2026, with Simon Willison publishing a link post the same week, so developers can run Claude Code, Codex, or Pi on a Mac while Bash executes inside Linux you control.
The pattern targets a practical fear when trying smaller local models: a mistaken or prompt-injected command should not read your SSH keys, .env, or calendar. explainx.ai covered the opposite failure mode in the Hugging Face agent intrusion timeline — agents that escaped sandboxes and copied CI credentials. External sandboxes are a host-side answer for daily coding, not a certificate of perfection.
What “external sandbox” means
Prime Radiant contrasts two designs:
| Approach | Agent location | Typical trade-off |
|---|---|---|
| In-sandbox agent | Agent and tools live inside Fly Sprites-style guests | Strong isolation, awkward self-modification |
| External sandbox | Agent on host; only execution crosses the boundary | Clearer audit path; host tools need separate policy |
Prime Radiant chose external so the agent cannot rewrite its harness inside the guest. Willison’s link post calls the boundary easier to audit — important when you compare against Superpowers, which already disciplines workflow but not kernel isolation.
Three interchangeable backends
All three servers speak the External Sandbox protocol on localhost:
external-sandbox-v86 (Node + WebAssembly)
The v86 backend bundles Alpine Linux inside WebAssembly. Selected host directories mount live over 9p — reads see host files and writable mounts change them immediately. No Docker daemon is required at runtime.
external-sandbox-container (Python + Apple Containers)
Wraps Apple Containers running Linux. Commands arrive through the shared HTTP/WebSocket protocol; the Python server manages container lifecycle.
external-sandbox-quicksand (Python + QEMU)
Uses Microsoft Quicksand wheels that ship QEMU and Alpine so installers do not manage VM images manually.
Pick the backend that matches your machine: v86 for portable demos, Containers on Apple Silicon with container support, Quicksand when you want full QEMU semantics.
Defaults Prime Radiant enforces
External sandbox HTTP proxy allow list editor and request log
Image: Prime Radiant
From the Prime Radiant post:
- Folder mounts — you choose read-only vs read-write paths exposed to guest Bash.
- Network off by default — enable
--proxyfor HTTP/HTTPS with host allow lists. - Credential replacement — the proxy can attach API keys outside the guest so the model never sees secrets.
- Live policy UI — browser terminal, proxy editor, and request logs while the sandbox runs.
- Agent interchangeability — any supported agent can talk to any compatible server.
That last point matters for teams comparing Codex harness updates with Claude Code plugin directories: the sandbox layer can stay constant while agents swap.
How to try it (high level)
Pi agent uname output from Alpine inside the external sandbox
Image: Prime Radiant
Prime Radiant’s post includes npx one-liners for the v86 demo and per-agent wiring guides in the external-sandbox repo. Typical flow:
- Start a sandbox server (v86, container, or quicksand) on localhost.
- Mount only the git worktree you want the model to touch; keep
~/.sshunmounted. - Configure Claude Code, Codex, or Pi to prefix Bash invocations through the sandbox client.
- Optionally add
--proxywith explicit host allow lists for package registries or inference APIs. - Use read-only mounts when experimenting with untrusted prompts.
Conformance tests live in the monorepo so implementers can verify protocol compatibility before trusting automation.
Security limits you should not ignore
External sandbox web terminal showing blocked and allowed network requests
Image: Prime Radiant
Prime Radiant and Willison repeat the same cautions:
- Experimental prototypes — not audited for classified or regulated data.
- Read-write mounts — a compromised agent can still delete or encrypt anything in mounted folders; keep version control handy.
- Linux guests vs macOS artifacts —
node_modulesor.venvbuilt on macOS may need reinstall inside the guest. - Partial tool routing on Claude Code — Bash may be sandboxed while Read/Edit still hit the host unless you add policies (see community analysis on subagentic.ai).
For enterprise threat models, pair external sandboxes with network egress monitoring similar to lessons from MCP tool provider misbinding and Spillway Guard prompt-injection defenses. Teams evaluating commercial guardrails can review AgentBeam for blocking dangerous agent actions before they reach production systems — complementary to sandboxing, not a replacement.
Why this matters now
Three forces collide in November 2026:
- Local and mid-size models — builders want cheaper inference but fear injection on privileged laptops.
- Agent malware pressure — regulators and customers remember OpenAI’s Hugging Face incident and Java4Shell/CVE reporting tied to frontier models.
- Skills frameworks — Superpowers and FFmpeg skills for local video MCP multiply command surfaces.
External sandboxes do not replace code review or CI policies. They give individuals a repeatable Linux choke point for Bash — the tool models abuse most often.
Comparison to other isolation stacks
| Stack | Isolation shape | Agent location |
|---|---|---|
| Prime Radiant external sandbox | Linux guest via v86/QEMU/Containers | Agent on host |
| Fly Sprites (in-sandbox pattern) | Remote microVM | Agent inside guest |
| macOS sandbox-exec profiles | OS-level policy | Agent on host |
| Prime Agent harness warning | Not a security sandbox | Agent on host with user permissions |
Choose external sandboxes when you want fast iteration on a laptop with explicit mount and proxy knobs. Choose remote microVMs when policy demands network-off guests in a datacenter.
What developers should watch next
Prime Radiant positions these repos as pattern prototypes, inviting other backends that honor the same protocol. Watch for:
- Conformance runner results on new implementations.
- Claude Code patches that narrow Read/Edit host leakage.
- Enterprise distributions bundling proxy allow lists with Microsoft Foundry agents.
Step-by-step: v86 demo path
Prime Radiant’s simplest path uses external-sandbox-v86:
- Install or
npxthe v86 server per the GitHub README. - Mount one git worktree read-write; mount everything else read-only or not at all.
- Point Claude Code’s Bash prefix (or Codex/Pi equivalent) at the localhost client from the external-sandbox monorepo.
- Run a harmless command (
uname -a,pwd) and confirm output originates from Alpine inside WASM. - Enable
--proxyonly if the guest needs package indexes; add one host at a time. - Store API keys in the proxy credential table, not in
.envinside the mount.
If step 6 fails, you have recreated the Hugging Face CI key copy mistake — secrets in a folder the model can read.
Protocol surface: what agents call
The shared protocol covers:
- Discovery — health and capability endpoints on localhost.
- Buffered execution — one-shot shell commands with stdout/stderr return.
- Streaming execution — WebSocket
startmessages for long-running processes (documented on the v86 repo forws://127.0.0.1:8686/exec/ws). - Optional proxy profiles — HTTP allow lists and credential injection.
Conformance tests in the monorepo exist so a fourth backend (for example Firecracker on a remote host) could ship without forking agent clients.
Apple Container vs Quicksand: when to pick which
| Backend | Best for | Caveat |
|---|---|---|
| v86 / WASM | Quick laptop demos, CI screenshots | Performance ceiling on heavy builds |
| Apple Containers | Apple Silicon devs with container tooling | Requires supported macOS container stack |
| Quicksand + QEMU | Closest to “real VM” semantics | Larger download via Python wheels |
None replace production hardened isolation; all three are labeled experimental.
Threat model: what external sandboxes stop and do not stop
Stops (when configured well):
- Casual
rm -rf /on your Mac home directory from Bash tool calls. - Drive-by curl | bash to unknown hosts without proxy allow lists.
- Stolen API keys in prompts if keys live only in the proxy injector.
Does not stop:
- Host Read/Edit paths on Claude Code unless you add extra policy (see subagentic analysis).
- Social engineering that tricks you into mounting
~read-write. - Supply-chain malware already inside the git repo you mounted.
Pair sandboxes with branch protection and code review the same way you would for human contributors.
Comparison to Fly Sprites and remote microVMs
Fly Sprites and similar products run the agent inside the guest. Prime Radiant optimizes for local iteration: same laptop, same IDE, but execution delegation.
Choose remote microVMs when policy mandates no sensitive mounts on the host at all. Choose external sandboxes when you want minutes-to-try isolation before investing in cloud sandbox fleets — a pattern Oracle discussed for OpenAI agent sandboxes on OCI at datacenter scale.
Operational tips from Prime Radiant’s warnings
- Keep read-write mounts under git; treat sandbox damage like a bad rebase.
- Rebuild Linux-native
node_modulesinside the guest when macOS binaries break. - Read proxy request logs after every untrusted prompt test — unexpected hosts mean your allow list leaked.
- Run conformance tests after upgrading any single backend package.
FAQ alignment: “how to sandbox Claude Code”
Readers searching how to sandbox Claude Code locally should start with Prime Radiant’s external pattern rather than disabling Bash entirely:
- External sandbox server running.
- Bash-only routing configured.
- Read/Edit restricted or monitored separately.
- Proxy off until you need registry access.
That is more usable than full sandbox-in-Docker for daily feature work, and more honest than claiming macOS seatbelt profiles alone stop injection.
Connecting to explainx.ai workshops
Teams standardizing agent workflows often need shared harness rules before shared sandboxes. explainx.ai’s Claude Code workshop listings and loop engineering guide complement this hardware layer — process first, isolation second.
