PARAS MADAN
All writing

Latest in AI

External Sandboxes for Coding Agents: Check Which Tools Still Run on Your Host

Prime Radiant's new sandbox prototypes separate command execution from the agent, but mounts, native tools and network permissions still need a careful review.

Prime Radiant has released external sandbox prototypes for coding agents. The agent stays on your computer while selected operations run in a separate Linux environment. Before adopting one, check which tools actually cross that boundary: Claude Code's native file-reading and editing tools still run on the host.

That distinction matters more than the word “sandbox.” A shell command can be isolated while another tool retains direct access to the same files you meant to protect.

Choose the integration, not just the backend

The launch guide introduces three interchangeable backends: v86 through WebAssembly, Apple Containers and Quicksand through QEMU. These are prototypes, not a claim that every agent configuration is equally contained.

Claude Code's integration redirects Bash commands. Codex's integration covers process and filesystem operations, while Pi's extension replaces its coding tools. I would choose the agent integration first, then decide which backend meets the workload's needs.

For Claude Code, keep host-side permissions in your threat model. Do not conclude that a denied shell read proves the agent cannot read that file through another tool. Test each available route separately with harmless files, rather than asking the model whether it believes it is sandboxed.

Start with a disposable project and Pi's opt-in extension

The Pi extension documentation requires Pi 1.5 or later and Node.js 22.19 or later. It routes the standard coding tools and interactive shell commands to the server, reporting an error rather than falling back to local execution when the server is unavailable.

For a first trial, use a disposable project directory containing no credentials. Start the backend there, then launch Pi in a second terminal with the extension enabled only for that session:

npx external-sandbox-v86 --preserve-paths --mount-rw "project=$PWD"
pi -e npm:external-sandbox-pi --no-builtin-tools --sandbox-url http://127.0.0.1:8686

These are the project's documented commands, not a setup I have tested. Review the packages before running them. The --no-builtin-tools option is important: it removes Pi's local tools rather than leaving them available if the extension fails to load. Confirm the sandbox status indicator, then inspect a harmless command's output.

A writable mount is still your real project

The v86 backend README describes live host-directory mounts. Writes through a writable mount immediately change the host files; they are not waiting in a separate copy for approval.

That makes a clean checkout or disposable copy a better first target than your only working directory. Record the starting revision, keep unrelated files outside the mount and review the diff afterward. If the task needs a reference folder but should not modify it, use a read-only mount instead.

The backend also uses a 32-bit Alpine guest. Host Node.js does not mean Node and npm are installed inside that guest. Check the actual architecture and available tools before interpreting a failed build as a problem with the agent or your application.

Separate network access from credential visibility

The launch guide describes networking as off by default, with an optional proxy that allows selected destinations and methods. Its credential replacement feature can attach a host-held secret without exposing the secret value inside the sandbox.

That reduces one kind of exposure, but it does not make the permitted API action harmless. An agent that cannot read a token may still use the authority the proxy grants. Start with the smallest useful destination and method set, and avoid granting write access merely to make a read-only task easier.

I would validate a denied destination and a denied method before using real account access. A successful permitted request proves connectivity; it does not prove the restrictions work.

Make failure visible before trusting unattended work

The shared protocol distinguishes command exit status, timeout and output-limit exhaustion. An HTTP 200 response can contain a failed command. Client code must inspect the result rather than treating transport success as task success.

My proposed acceptance check is simple: stop the server during a harmless task, attempt an unavailable path, and run a deliberately failing command. Verify that each failure stays visible and that none silently switches to host execution. Those checks establish the boundary you configured, not a blanket guarantee about all future extensions or agent versions.

I'm Paras. I work at the intersection of AI, engineering and distribution.

I help developer-tool teams turn agent architecture and security boundaries into clear technical stories.

Book a 30-minute call.