top of page

Prime Radiant: External Sandboxes for Coding Agents

25 minutes ago
11 min read

Simon Willison and Prime Radiant released three experimental sandbox implementations on November 17, 2026, separating coding agents from the environments executing their commands. External sandboxes for coding agents put generated code inside an isolated Linux environment while keeping the agent outside. That separation offers a concrete security control, but its reach depends on which tools actually cross the boundary.

The release targets developers experimenting with local models, where mistakes and malicious instructions can turn ordinary coding tasks into damaging actions. Prompt injection, an attack that steers an agent through untrusted content, is part of the motivation. The central tension is between giving an agent enough access to finish work and limiting what that access can damage.

Claude Code, Codex, and Pi provide the immediate comparison. Each connects differently, so sharing an execution environment does not mean sharing identical protection. For developers and engineering teams, the announcement raises a practical question: which capabilities remain on the host after command execution moves elsewhere?

External sandboxes for coding agents get three implementations

Willison describes the project as an experiment in safer execution, developed with Prime Radiant, the research lab behind Superpowers. His external sandbox announcement identifies three implementations that expose a common local interface.

A sandbox is a restricted execution environment that limits the resources running code can reach. In this pattern, the agent sends work to that environment instead of executing commands directly on its own machine. The agent continues managing the conversation and deciding what to do.

The release makes the execution boundary interchangeable while leaving the agent outside that boundary.

An application programming interface, or API, defines how software components exchange requests and results. Here, a localhost API, reachable through the same computer, connects the agent to the sandbox server. That interface separates the agent integration from the technology running the code.

The distinction matters because an execution environment and an agent serve different purposes. The environment controls access to resources. The agent interprets a task, chooses tools, and responds to results. Combining those responsibilities can make it harder to identify where a restriction actually applies.

Separating them creates a more explicit question for anyone evaluating the system: what request leaves the agent, and what authority receives it? That question is more useful than treating an entire coding session as a single trusted activity.

Consider a hypothetical maintenance task involving an unfamiliar repository. The agent needs to inspect files, run tests, and propose changes. Running those commands in a restricted environment can reduce their reach beyond the assigned project. It does not establish that the proposed changes are correct.

The same distinction applies when a dependency executes an installation script. The relevant boundary concerns the permissions available to that script. Whether the model intended the resulting behavior is a separate issue. An accidental command and a malicious command can exercise the same granted capability.

This is why the announcement deserves attention beyond its installation examples. It presents an architecture that developers can inspect and compare. It does not require accepting the model's judgment as the mechanism that enforces every restriction.

The immediate change is therefore specific. Prime Radiant has published compatible prototypes for routing execution into separate environments. The broader implication is analytical: model choice and execution policy can be evaluated as related but distinct decisions.

That separation also clarifies responsibility. A model can recommend an action, an integration can route it, and an execution environment can restrict it. Evaluating the complete workflow requires examining each handoff rather than assuming the final restriction covers everything upstream.

A shared interface does not make the backends equivalent

The three implementations use different foundations. Their shared interface makes comparison possible, but it does not establish equal performance, compatibility, or security.

The v86 sandbox implementation uses a Node.js server and v86, an x86 emulator compiled to WebAssembly, to run Alpine Linux. WebAssembly is a portable executable format used here as part of the emulation stack. The repository describes a minimal guest environment, with additional tools available through startup configuration.

The Apple Containers implementation uses a Python server around Apple's container tooling. Its documentation describes disposable environment changes alongside persistent writes to mounted host folders. It also explicitly distinguishes its filesystem behavior from the v86 implementation.

The Quicksand sandbox implementation uses Microsoft's Quicksand library with QEMU, software that runs virtual machines. A virtual machine provides a guest operating system separated from the host through a virtualization or emulation layer. This implementation also documents its own mounting and networking mechanisms.

Compatibility at the interface does not imply equivalence beneath it.

For an engineering team, the useful consequence is freedom to evaluate the execution technology without redesigning the entire agent workflow. That reduces the conceptual coupling between a coding assistant and its execution environment.

However, choosing among these implementations still requires a workload. A small scripting task and a dependency-heavy application build exercise different parts of an environment. A successful demonstration of the former cannot establish suitability for the latter.

Package availability is another practical distinction. A host-side runtime does not automatically exist inside the guest. Developers evaluating an isolated workflow need to distinguish the software serving requests from the software available to execute them.

This can otherwise produce confusing failures. A command that works on a developer's machine can fail inside a restricted environment because a runtime is missing. That failure says little about the agent's reasoning and nothing definitive about the isolation boundary.

The same caution applies to speed. The announcement does not establish a controlled performance ranking across the implementations. A responsible comparison would hold the task, dependency state, hardware, and measurement method constant.

Operational convenience also deserves separate treatment. A backend that fits an existing development setup can be easier to evaluate. That convenience does not automatically make its restrictions stronger. Conversely, a more complicated setup is not evidence of better protection.

The release's common interface is valuable precisely because these questions remain separate. Developers can ask whether the agent integration works, whether the application builds, and whether the intended restrictions hold.

Those are different acceptance criteria. Collapsing them into a single successful terminal session would hide the most consequential differences between the backends.

For buyers, this also changes the evidence worth requesting. A recognizable isolation technology is a starting point. The useful evidence concerns how a particular implementation exposes files, mediates traffic, handles failures, and interacts with the selected agent.

Claude Code exposes the difference between commands and tools

The most consequential qualification appears in Prime Radiant's agent integration details. Claude Code routes Bash commands into the sandbox, while its native Read and Edit tools remain on the host.

Bash is a command shell that executes scripts and terminal commands. Redirecting Bash changes where those commands run. It does not automatically redirect every other capability offered by the agent.

The announcement describes broader routing for the other integrations. Codex sends process and filesystem operations, including its native patch operation. Pi replaces its listed execution and file tools, with built-in tools disabled in the documented setup.

Prime Radiant also calls the implementations experimental prototypes that have not received sufficient auditing for sensitive workloads. Those qualifications belong beside the functionality, rather than buried beneath a general claim of safety.

The security question is which tools cross the boundary, not simply whether the workflow includes a sandbox.

This distinction puts pressure on developers building agent integrations. A shell wrapper can be useful while covering only part of the agent's capabilities. The integration must make that scope understandable to the person assigning work.

Imagine a hypothetical task that asks an agent to inspect a repository and update a configuration file. The agent might inspect files through a native reader, execute tests through Bash, and edit through a separate tool. Those actions can follow different routes.

A Linux response from a terminal command establishes where that command executed. It does not establish where the preceding read or subsequent edit occurred. Treating it as proof of complete containment would confuse a visible result with the scope of enforcement.

For Claude Code, the documented distinction is especially concrete. Restrictions on the sandbox's mounted folders do not become restrictions on native host-side Read and Edit operations. Additional host permissions therefore remain relevant.

That does not make the shell integration pointless. Build tools, scripts, and subprocesses can still represent a meaningful execution surface. The important limitation is that reducing that surface's reach does not describe the authority of every remaining tool.

This is also why comparisons among Claude Code, Codex, and Pi should avoid a simple protected-or-unprotected label. The integration path matters as much as the selected backend. Users need to understand both before interpreting a successful task.

For enterprise teams, the implication is organizational. The developer configuring an execution server might not control every extension or connection available to an agent. A complete evaluation needs an inventory of capabilities, including those that remain outside the execution service.

That inventory can be more revealing than a broad product description. It shows where enforcement exists and where another policy must carry the responsibility.

The release therefore challenges loose language around agent isolation. A precise description identifies the routed operations, the remaining host capabilities, and the expected behavior when the external environment becomes unavailable.

Files and network access determine the remaining reach

External sandboxes for coding agents make resource permissions a central part of the design. The key tradeoff is straightforward: useful work requires access, and every granted capability creates an intended path across the boundary.

The shared sandbox protocol defines observable behavior for execution, filesystem operations, and optional features. It explicitly avoids promising identical backend performance or mount semantics.

A mount makes a selected host directory available inside the guest environment. Read-only access permits inspection; read-write access also permits changes. The protocol treats access to mounted host files as deliberate exposure, not an escape.

A working isolation boundary can still permit damage to resources intentionally placed inside its reach.

Consider a hypothetical repository mounted for editing. An agent needs write access to change source files. If it deletes those files through an authorized operation, the result can be destructive even though the boundary behaved as configured.

The analytical consequence is important: containment and preservation are different goals. Containment concerns where an operation can reach. Preservation concerns whether valuable state remains recoverable after an allowed operation goes wrong.

A narrow writable workspace can serve both development and review better than broad access to unrelated folders. The point is not that every project needs the same arrangement. It is that the assigned task should explain each grant of access.

Sensitive material inside the project deserves the same scrutiny. A directory boundary does not understand which files contain ordinary fixtures and which contain confidential information. If the environment can read both, the operator has exposed both.

Network permissions introduce a similar tradeoff. A proxy is an intermediary that receives and forwards network requests. An allowlist specifies the destinations or operations permitted through that intermediary.

The architectural benefit is mediation: network access becomes something an external component can evaluate. The limitation is semantic. Permission to contact a destination does not establish that every permitted request serves the user's intended task.

For example, a hypothetical workflow might need to retrieve dependency metadata. That requirement does not inherently justify unrelated write operations against another service. Defining the required action narrowly makes the permission easier to evaluate.

HTTP methods, which identify request actions, provide one way to distinguish operations. Paths can further narrow the requested resource. Even then, reviewers need to understand the service receiving the request rather than relying on labels alone.

Credential replacement adds another distinction. A credential is a secret used to authenticate access. Keeping its value outside generated code can reduce direct exposure, but the authenticated operation still carries authority.

An agent that cannot print a secret might still request an action authorized by that secret. Secret confidentiality and permission control therefore answer different questions. Evaluating only the former leaves the latter unresolved.

This is the central tradeoff in the announcement. Developers gain explicit controls over execution resources, but those controls require decisions about the work being authorized. Isolation does not eliminate those decisions; it makes their consequences easier to identify.

The prototypes need evidence beyond successful demonstrations

The strongest skeptical reading does not require assuming the design is ineffective. It requires keeping the available evidence within its actual scope.

A demonstration can establish that a particular command ran inside a particular environment. A compatibility test can establish that a client exchanged expected messages. Neither result, by itself, establishes resistance to an adversarial attempt to cross the boundary.

Functional correctness, policy enforcement, and security assurance require different evidence.

The published protocol is helpful because it describes expected behavior in terms that can be tested. However, conforming to an interface does not certify every property of the underlying implementation.

This matters when comparing the backends. An identical response to an ordinary file operation can conceal different enforcement mechanisms. Those differences deserve attention when evaluating unusual file layouts, concurrent changes, or hostile inputs.

The relevant question is not whether all implementation details must appear in a launch announcement. It is whether a team understands which claims the announcement establishes and which require further validation.

For sensitive workloads, a documented threat model would be particularly useful. A threat model states the attacker capabilities and protected resources a system is designed around. Without one, different readers can interpret the same claim against different assumptions.

One reader might worry about accidental deletion during a coding task. Another might worry about malicious repository content. A third might assume protection against hostile software already running on the host.

Those are materially different scenarios. A design can address part of one scenario without addressing all the others. Clear scope prevents a useful control from becoming an unsupported promise.

Host-side exposure remains another evaluation area. Because the agent lives outside the execution environment, its surrounding permissions still matter. Moving generated code elsewhere does not, by itself, relocate the conversation, model connection, or unrelated host tools.

Organizations should also distinguish task success from acceptable behavior. An agent can complete a requested change while requesting unnecessary permissions along the way. Conversely, a blocked request can represent successful enforcement even when the task stops.

That creates a measurement challenge. Productivity measures reward completion, while isolation controls sometimes need to interrupt completion. Evaluating both requires recording why an action failed and whether the failure matched the intended policy.

Documentation and recovery procedures matter for the same reason. A denied operation should not automatically become an invitation to widen access. The operator needs enough context to decide whether the task genuinely requires that permission.

Teams can preserve their evaluation notes alongside local technical documents. Recording the agent, backend, granted resources, and observed result makes later comparisons more meaningful.

None of this establishes that a specific flaw exists in the prototypes. It identifies the evidence needed before expanding their role. The release supports experimentation; broader trust requires results tied to a clearly defined workload and threat model.

What would make external sandboxes ready for wider use?

The next evaluation period should focus on evidence rather than a larger collection of demonstrations. Three signals would strengthen or weaken the case for this architecture in practical development.

The decisive signals are independent boundary testing, complete tool routing, and usable permission policies.

First, watch for independent security analysis of the implementations. A useful assessment would identify the protected resources, attacker capabilities, tested versions, findings, and remediation. A general endorsement would provide less information than a narrowly scoped technical review.

Published findings would not automatically discredit the architecture. They would make its limits more concrete. The important distinction would be between issues resolved through implementation changes and assumptions requiring a different deployment model.

Conversely, continued demonstrations without clearer security evidence would leave the sensitive-workload question open. Successful task completion cannot fill that gap, regardless of how polished the interface becomes.

Second, watch whether agent integrations make coverage explicit and maintain it across updates. Users should be able to identify which operations enter the external environment and which retain host authority.

This signal matters especially where tools take different routes. Clear coverage documentation would strengthen confidence in the integration's stated scope. Unexplained local fallbacks or ambiguous routing would weaken it.

Compatibility also needs maintenance. An integration can depend on behavior outside the sandbox implementation itself. Teams need evidence that the supported combination still behaves as documented after either component changes.

Third, watch whether ordinary work fits within understandable permission policies. A prototype is easier to trust operationally when users can explain why each directory and network permission exists.

A useful adoption report would describe the task and the permissions it required. It would also identify blocked operations, compatibility problems, and any exceptions added to finish the work. Completion alone would leave too much unexplained.

These signals keep the evaluation grounded. Independent testing addresses resistance to misuse. Routing clarity addresses the scope of enforcement. Permission usability addresses whether people can preserve that scope while doing useful work.

External sandboxes for coding agents offer a concrete way to investigate these questions without treating the model as the sole decision-maker about safety. Their value rests on making authority visible and enforceable at the execution boundary.

For developers evaluating the release, start with a disposable project and a clearly defined task. Record which operations belong inside the sandbox and which capabilities remain on the host. Compare the permissions needed for completion with those granted initially. Treat requests for broader access as evidence about the workflow, rather than routine setup noise. Review both the resulting code and the actions taken to produce it. Then examine whether the same task remains workable under the intended restrictions. That process will reveal more than a successful terminal screenshot. Before expanding an agent's access, can your team explain what remains protected when the agent makes the wrong decision?

Give every agent the context to do better work

Connect your agents to the knowledge, decisions, and history already organized in remio.

remio currently supports Windows 10+ (x64) and Macs with Apple silicon.

Your AI Partner at Work
Get more done with remio

Plan. Create. Deliver.
All in one place.

bottom of page