Skip to content
AgentEnv Framework

Sandboxes

Sandbox = The isolated machine or container that your environment or agent resides in

New to AgentEnv Framework? Getting Started installs it and runs a first task in two commands, with no Docker, model or cloud account, and Core Concepts explains environments, agents and tasks. Every provider below runs the same tasks; the default, local, needs only Docker.

Supported Providers

ProviderA sandbox isEgress allowlistNeeds
local (default)containers on your own DockernoDocker
modala Modal container for each env service and agentyesa Modal token
modal_vma Modal VM with Docker inside, one per envyesa Modal token
coreweavea CoreWeave Sandbox: a container running an agent's own image, or a VM with Docker inside for an envyesthe coreweave extra and a CoreWeave or W&B API key
e2ban E2B sandbox with Docker insideyesan E2B API key and template
sail_vma Sail Sailbox, a root VM with Docker insideyesthe sail extra and a Sail API key
tensorlakea Tensorlake MicroVM with Docker insideyesthe tensorlake extra and a Tensorlake API key
tenkia Tenki Sandbox Linux VM with Docker insideyesthe tenki extra and a Tenki API key
vercela Vercel Sandbox with Docker insideyesthe vercel extra and Vercel credentials
smol_vma SmolVM microVM on your own machine, with Docker insidenothe smol extra, and Apple Silicon macOS or Linux with /dev/kvm
boxda boxd machine, a hardware-isolated VM with Docker running insideyesthe boxd extra and a boxd API key
daytonaa Daytona sandbox with Docker running insideyes, on Tier 3the daytona extra and a Daytona API key
boata boat sandbox, an Ubuntu VM with Docker running insidenothe boat extra and a boat API key
agent37an Agent37 VM with Docker running insidenoan Agent37 API key
lumea macOS VM on your own Mac, run by Lume, for macOS computer envsnoan Apple-silicon Mac with Lume, and a logged-in session

A deploy_sandbox or deploy_agent step with a network_policy gets a sandbox that only reaches the hosts the policy allows. A provider that can't enforce the policy refuses the step instead of creating an open sandbox. To run on a platform that isn't listed, write a sandbox provider plugin.

Picking a Provider

.agentenv/config.toml
[sandbox]
default       = "local"   # envs and deploy_sandbox steps
agent_default = "local"   # agents

A comma-separated value, such as "sail_vm,e2b", is a fallback chain: when one provider can't create a sandbox, the next one is tried. For a single run, --sandbox on agent-env run, or --env-sandbox and --agent-sandbox on agent-env task run, override the config. A provider's own settings go in [sandbox.providers.<name>.config], with keys given as secret: or env: references, never as the key itself.

modal and modal_vm read MODAL_TOKEN_ID and MODAL_TOKEN_SECRET, or else the active profile in ~/.modal.toml that modal token new writes, so they need no config table.

CoreWeave

pip install 'agentenv-framework[coreweave]'
.agentenv/config.toml
[sandbox.providers.coreweave.config]
api_key = "env:CWSANDBOX_API_KEY"   # or wandb_api_key = "env:WANDB_API_KEY"

Each env gets a CoreWeave Sandbox with Docker inside, and each agent runs its own image in one of its own. The coreweave provider covers the rest.

E2B

e2b needs an E2B template with Docker and Compose v2. Build one with the Docker Compose example in E2B's Docker guide, then set base_template to its name. agent-env builds each sandbox size it needs from that template.

.agentenv/config.toml
[sandbox.providers.e2b.config]
api_key       = "env:E2B_API_KEY"
base_template = "docker-compose"   # the template the guide builds

Sail

pip install 'agentenv-framework[sail]'
.agentenv/config.toml
[sandbox.providers.sail_vm.config]
api_key = "env:SAIL_API_KEY"

agent-env run hello --sandbox sail_vm checks the setup with no model. Sail injects an agent's model key and [model.headers] at its egress, so neither enters the Sailbox. The sail_vm README covers sizes, auto-sleep, egress and cost.

Tensorlake

pip install 'agentenv-framework[tensorlake]'
.agentenv/config.toml
[sandbox.providers.tensorlake.config]
api_key = "env:TENSORLAKE_API_KEY"

agent-env run hello --sandbox tensorlake checks the setup with no model. Sandboxes boot from agentenv-dind-host-v1, a public image with Docker and Compose v2; set image to boot your own. The tensorlake README covers sizes, egress and cost.

Tenki

pip install 'agentenv-framework[tenki]'
.agentenv/config.toml
[sandbox.providers.tenki.config]
api_key = "env:TENKI_API_KEY"

agent-env run hello --sandbox tenki checks the setup with no model. Each env and each agent gets a Linux VM of its own, with Docker inside and a public HTTPS URL for each port it exposes. The tenki README covers sizes, egress and cost.

Vercel

pip install 'agentenv-framework[vercel]'
.agentenv/config.toml
[sandbox.providers.vercel.config]
token      = "env:VERCEL_TOKEN"
team_id    = "your-team-id"
project_id = "your-project-id"

agent-env run hello --sandbox vercel checks the setup with no model. Set token, team_id and project_id together, or leave out the table to use the Vercel SDK's own credentials, such as a VERCEL_OIDC_TOKEN from vercel project token <project>. Each env and each agent gets a Vercel Sandbox of its own, with Docker inside and a public *.vercel.run URL for each port it exposes. A request gets the smallest size that covers its CPU and memory, at 2 GB per vCPU and up to 32 vCPUs, and every sandbox has a fixed 64 GB disk. region and failover_regions pick where sandboxes run, and egress allowlists take hostnames and CIDR ranges.

smol machines

pip install 'agentenv-framework[smol]'

agent-env run hello --sandbox smol_vm checks the setup with no model. Each env and each agent gets a SmolVM microVM of its own on your machine, with Docker inside, so it needs no account, API key or config table, and nothing runs on your host's Docker. It needs Apple Silicon macOS, or Linux with /dev/kvm; on Apple Silicon, build images for linux/arm64. The local object and image stores work as they are: guests fetch local objects, and each VM forwards image pulls to your host's registry.

boxd

pip install 'agentenv-framework[boxd]'
.agentenv/config.toml
[sandbox.providers.boxd.config]
api_key = "env:BOXD_API_KEY"

agent-env run hello --sandbox boxd checks the setup with no model. Each env and each agent gets its own boxd machine with Docker inside, and the boxd README covers the rest.

Daytona

pip install 'agentenv-framework[daytona]'
.agentenv/config.toml
[sandbox.providers.daytona.config]
api_key = "env:DAYTONA_API_KEY"

agent-env run hello --sandbox daytona checks the setup with no model. Each env and each agent gets its own Daytona sandbox with Docker inside, and the daytona README covers the rest.

boat

pip install 'agentenv-framework[boat]'
.agentenv/config.toml
[sandbox.providers.boat.config]
api_key = "env:BOAT_API_KEY"

agent-env run hello --sandbox boat checks the setup with no model. Each env and each agent gets its own boat sandbox with Docker inside, and the boat provider covers the rest.

Agent37

.agentenv/config.toml
[sandbox.providers.agent37.config]
api_key = "env:AGENT37_API_KEY"

It needs no extra, and agent-env run hello --sandbox agent37 checks the setup with no model. Each env and each agent gets its own Agent37 VM with Docker inside, and the agent37 README covers the rest.

Lume

lume runs macOS computers on your own Mac: each deploy boots a clone of the computer's VM bundle in Lume, so it needs an Apple-silicon Mac with Lume installed and agent-env running in a logged-in session. It runs macOS computer envs only, at most two at once as Apple's licence allows, and the lume provider covers its settings.

Last updated on

Ask a question · Report an issue

On this page