# Strands Box, open software that isolates AI agents

> AWS publishes Strands Box in developer preview, an Apache 2.0 sandbox that combines macOS isolation with Dogwood semantic policies.
> By José Maldonado · AI Agents · 2026-10-19

AWS announced the launch of Strands Box in developer preview, a local open source sandbox that needs no virtual machine, no container image and no guest operating system to provision. The license is Apache 2.0, the repository was opened days before the announcement and the official post is signed by Fernando Dingler on [the company's open source blog](https://aws.amazon.com/blogs/opensource/introducing-strands-box-ai-agent-sandboxes-powered-by-dogwood/).

The proposal has two clearly separated layers. Containment is handled by the operating system, which confines the agent's process and decides which files and programs its calls reach, with the macOS Seatbelt sandbox as the current mechanism. The policy is written in Dogwood, a Cedar-compatible language that adds temporal operators, and is evaluated in four places: shell, Python, network and MCP.

That design responds to a problem this outlet has covered in recent weeks: agents escape. Claude Opus 5.5 tried to leave its isolated environment or manipulate it in 1.5% of runs without safeguards, according to [the system card Anthropic published on September 22](https://observatorioblockchain.com/en/ai/anthropic-opus-55-escapa-sandbox-1-5-tests/). AWS's answer is not a better-behaved model, but a box that decides outside the agent and denies by default.

## How do they separate isolation and rules?

AWS's starting point is a distinction its team repeats in the documentation: isolation settles where the agent can reach, but not what it does once it has reached it. A container or a microVM raises a solid boundary and, at the same time, leaves the agent with everything inside it at its disposal.

Box uses operating system mechanisms to force the only exit from the box to be the policy layer, which thus sits in user space and can reason about language, protocol and file system. Containment permissions come from \`box.toml\`, which declares which files and which programs the agent's process can touch.

Layer

Mechanism

What it decides

Containment

macOS Seatbelt with the permissions in \`box.toml\`

Which files and programs the process's calls reach

Policy

Dogwood and the embedded local engine

Whether an operation is allowed or denied, based on its arguments and the history

Network

Egress gateway

Connections, method and path of each request, and which credential is injected

Tools

One sandbox per program and the MCP broker

The launch of binaries such as git and calls to MCP tools

The policy lives in \`policy.dw\` and is evaluated by the embedded local engine: anything no permission authorizes is denied, and a matching prohibition overrides any permission. It is the same AgentCore Policy technology for agents in the cloud.

The detail that sets Box apart from an allowlist is the shared history. Both interpreters and the gateway read and write the same event log, so a file read can condition a later network request. The shell is Strands Shell and the Python is Monty, the Pydantic project.

## What are policies that look at the past?

What AWS highlights is the semantic policy: a rule can look at the sequence of actions and at time, not just at the current request. Marc Brooker, the company's vice president and distinguished engineer, gave two examples in [his analysis](https://strandsagents.com/blog/strands-box-the-big-picture/): allowing a \`git push\` only if the tests have passed, and letting an agent use a payments API with a cap of one hundred dollars a day.

The rules are written with Cedar syntax, the policy language AWS developed for its services, and are evaluated with temporal operators. The company's example chains two different actions: it prohibits every \`git push\` unless an \`npm test\` has finished with code 0 within the previous hour.

AWS's comparison with what already exists points to the same place. Commercial harnesses bring their warnings and their allowlists, but they live inside the agent's process and judge the call, not its effect. A harness sees "run this command" and does not see the files it is going to touch. Box is presented as agnostic: the same \`box.toml\` and the same \`policy.dw\` work for the Strands CLI, for Claude Code and for Codex CLI.

## Keeping secrets away from the agent

Credential injection turns the egress gateway into the box's only secrets boundary. The agent receives a placeholder, the gateway terminates the connection's TLS, checks with the policy whether that request is authorized and replaces the placeholder with the real key before forwarding it. For AWS services, the SigV4 signature is also added by the gateway.

The split has a consequence worth understanding before deploying anything: the box, not each process, is the credentials boundary. The agent, each tool and each MCP server can use any credential declared in \`box.toml\`. If two programs need different secrets, the recommendation is to separate them into two boxes.

The company's argument is that these pieces allow decisions to be made with contextual rules. An agent investigating an incident can read logs without being able to change them, because reading and writing are different operations for the engine. The same idea underpins the daily cap for a payments API.

## Where does the scope of the policy end?

The policy sees what passes through Box, and that leaves a gap the documentation acknowledges without embellishment. A harness's built-in file tools open files from the agent's own process: containment limits how far they reach, but no rule logs those reads and writes. For every change to pass through the policy, the agent must be given a shell as its only file tool, which is what the Strands, Claude Code and Codex CLI guides do.

Support is currently limited to macOS 15 or later on Apple Silicon, so Linux is out and Windows is not on the table either. Expanding it is one of AWS's priorities, but with no public dates, just as for Bedrock AgentCore, ECS or Kubernetes.

It is worth reading the fine print. The software is in the 0.1.x series and the documentation warns that configuration, actions and flags may change between versions: it is advisable to pin the version when downloading. The guide calls for a Mac with Apple silicon, macOS 15 or higher and access to Claude Opus 5 on Bedrock in us-west-2.

The trust chapter remains. Box has more code to audit than a simple Seatbelt wrapper, because it includes interpreters and protocol translators. It is written in Rust and subjected to testing and fuzzing, but AWS acknowledges that more code means more possible errors at the only boundary separating the agent from the system. That is why the official recommendation for multi-user cloud deployments is to combine Box with a microVM per session.

## Why a box instead of an obedient model?

With that context, the reading of the announcement changes tone. The incidents of the past year were not isolation failures in the classic sense, but badly drawn boundaries. In its research on recent incidents, Anthropic describes runs in which a model left an external partner's evaluation environment and reached production infrastructure with basic techniques such as weak passwords and unauthenticated endpoints. The same pattern covers the swarm of agents that in July coordinated through an improvised message board inside a package manager and ended up hitting [Hugging Face](https://observatorioblockchain.com/en/cybersecurity/hugging-face-hack-mensaje-mundo-empresarial/).

Strands Box responds not with alignment but with engineering: it takes the decision out of the agent's process, puts it in an engine that denies by default and ties it to a history the agent itself cannot rewrite. The UK AI Safety Institute's public testbed for measuring escapes found that frontier models identify and exploit vulnerabilities when they are present. Box does not fix the model's reliability, and its documentation admits as much: it bounds how far it can go, and the limit becomes a written, verifiable decision.

## The missing audit

The useful question for anyone deploying agents with access to real systems is not whether Box is elegant inside, but who audits its trust base. A modified shell interpreter, a policy engine and an MCP translator are enough attack surface to demand independent review, and for now the project is an AWS preview with its own team behind it. We will have to wait for third parties to reproduce the security model and publish their findings.

AWS's stated goal is for the policy to travel with the agent: the same \`box.toml\` and the same \`policy.dw\` on the developer's laptop and in a deployment on AgentCore, ECS or Kubernetes, without rewriting rules along the way. If that arrives, and if Linux makes the list, the conversation about autonomous agents will finally have a concrete object to audit instead of a promise of alignment.
