Skip to main content
Sandboxes are instant-launching virtual machines serving as sandboxed compute runtimes for agents. You can securely run LLM-generated code inside these VMs making them ideal for agents that need access to an operating system to run commands with no risk of escaping. They provide a basic REST API interface for accessing the file system and processes, along with an MCP server that makes these capabilities available as tool calls.

Sandbox lifecycle

Unlike traditional sandbox infrastructure, Blaxel’s standout feature is fully managed lifecycle. Sandboxes resume from standby in under 25 milliseconds and automatically scale to zero after a few seconds of inactivity. This means that your sandboxes wait on standby indefinitely when not used, eliminating cold starts without complex orchestration. Memory state is maintained even after scaling down, including the running processes and entire filesystem. For cost-effective long-term persistence, you can attach volumes to sandboxes. Lifecycle of Blaxel Sandboxes

Active mode

Sandboxes stay active as long as there’s an active connection to them. You are charged for memory (based on how much you allocated at sandbox creation) and storage while a sandbox is in active mode. CPU resources are allocated accordingly by Blaxel based on your selected memory allocation and are not charged separately. Learn more about pricing.

Standby mode

If a sandbox does not have an active connection, it automatically transitions to a warm standby mode (also called scale-to-zero). This transition happens in approximately 15 seconds. If a sandbox has an ongoing WebSocket/TCP connection, there is a 15-minute idle timeout for such a connection. This means that if the WebSocket/TCP connection remains idle for 15 minutes with no activity, the sandbox will automatically transition to standby mode. When transitioning to standby mode, Blaxel automatically creates a snapshot of the entire state (including the complete file system in memory, preserving both files and running processes) and transitions the sandbox to standby mode within approximately 15 seconds. Reconnecting to the sandbox transitions it back to active mode. Any running processes are included in this snapshot and will be instantly restored when you reconnect to the sandbox. You are not charged for memory while a sandbox is in standby mode. However, you are charged for the storage of the snapshot and/or the volumes. Learn more about pricing.
To prevent a sandbox from going into standby, you can use WebSocket ping/pong keepalive messages or other techniques to prevent the timeout.

Deletion

In addition to automatic scale-to-zero, Blaxel also supports automatic sandbox deletion based on expiration policies. Starter quotas enforce time-to-live (TTLs), while higher quota tiers unlock sandboxes with unlimited persistence.
Automatic deletion differs from automatic standby (scale-to-zero). Deleted sandboxes cannot be recovered, while sandboxes in standby mode can be resumed instantly.

Sandbox deployment statuses

During the deployment process, the possible sandbox statuses are:
  • UPLOADING: A new sandbox version has just been uploaded; the build has not started yet.
  • BUILDING: A new sandbox version has been uploaded and the build is in progress.
  • DEPLOYING: The sandbox deployment is in progress.
  • DEPLOYED: The sandbox is ready to use. It is either in active mode or standby mode.
  • FAILED: An error occurred during the build or deployment of the sandbox.
  • TERMINATED: A TTL was set for the sandbox; it has been deleted and will be removed from the API/UI soon.
  • DELETING: A deletion request has been triggered and the deletion is in progress.
UPLOADING/BUILDING statuses only appear when using bl deploy from a sandbox template folder.

Use cases

Some examples of use cases include:
  • Code review agents that analyze repositories to detect the effects of changes. These agents run fully isolated compute environments for each tenant while keeping them snapshotted in standby between sessions, eliminating the need to clone the repo every time.
  • Code generation agents that iterate in their own compute environments, and instantly render live application previews as human users build, step away, and log back in.
  • Data analyst agents that execute adhoc data analysis workflows, generating scripts on-the-fly and running them securely against private files or data within an isolated, ZDR-compliant environment.
  • Background agents that operate beyond their pre-configured tools. Each agent gets its own “personal computer” where it can autonomously install packages, execute custom scripts, store files, and adapt to new requirements securely. They can parallelize dozens of those personal computers.

Create a sandbox

Using the SDKs

Create a new sandbox using the Blaxel SDK by specifying a name, image to use, deployment region, optional labels, and the ports to expose. Note that ports 80 (system), and 443 & 8080 (sandbox API) are reserved by Blaxel.
The Blaxel SDK authenticates with your workspace using credentials from these sources, in priority order:
  1. when running on Blaxel, authentication is handled automatically
  2. variables in your .env file (BL_WORKSPACE and BL_API_KEY, or see this page for other authentication options).
  3. environment variables from your machine
  4. configuration file created locally when you log in through Blaxel CLI (or deploy on Blaxel)
When developing locally, the recommended method is to just log in to your workspace with Blaxel CLI. This allows you to run Blaxel SDK functions that will automatically connect to your workspace without additional setup. When you deploy on Blaxel, this connection persists automatically.When running Blaxel SDK from a remote server that is not Blaxel-hosted, we recommend using environment variables as described in the third option above.
import { SandboxInstance } from "@blaxel/core";

// Create a new sandbox
const sandbox = await SandboxInstance.create({
  name: "my-sandbox",
  image: "blaxel/base-image:latest",   // public or custom image
  memory: 4096,   // in MB
  ports: [{ target: 3000, protocol: "HTTP" }],   // optional; ports to expose
  labels: { env: "dev", project: "my-project" }, // optional; labels
  region: "us-pdx-1"   // deployment region
});
An alternative is to use the helper function createIfNotExists() (TypeScript) / create_if_not_exists() (Python). This helper function either retrieves an existing sandbox or creates a new one if it doesn’t exist. Blaxel first checks for an existing sandbox with the provided name and either retrieves it or creates a new one using your specified configuration.
import { SandboxInstance } from "@blaxel/core";

// Create sandbox if it doesn't exist
const sandbox = await SandboxInstance.createIfNotExists({
  name: "my-sandbox",
  image: "blaxel/base-image:latest",  // public or custom image
  memory: 4096,    // in MB
  ports: [{ target: 3000, protocol: "HTTP" }],  // optional; ports to expose
  labels: { env: "dev", project: "my-project" }, // optional; labels
  region: "us-pdx-1"    // deployment region
});

Using the CLI and Console

It is also possible to create a sandbox via the Blaxel CLI or the Blaxel Console.
bl new sandbox my-sandbox
cd my-sandbox
bl deploy
This command initializes a new sandbox project and configuration file in the named directory my-sandbox and then deploys the sandbox on Blaxel.The project directory contains the Blaxel configuration file blaxel.toml, which can be further customized to suit your sandbox deployment requirements, by modifying the base image, memory, environment, etc. Learn more about the blaxel.toml file.
Running bl deploy here also saves the image to be reused later as a template.

Using the API

Although less common, it is also possible to create a sandbox by directly interacting with the Blaxel REST API.

Understand sandbox configuration

Images

The list of public images can be found here. To create a sandbox with one of those images, enter blaxel/{NAME}:latest (e.g. blaxel/nextjs:latest).
Custom sandbox images (or templates) enable you to create sandboxes with a consistent, customized set of tools, configurations, or entrypoint scripts.

Memory and filesystem

For maximum performance, Blaxel sandboxes store part of their filesystem in memory. The base of the filesystem (the user-supplied image) is stored as read-only files on host storage using a highly-efficient format called EROFS (Extendable Read-Only File System). On top of the read-only base, a writable layer lives entirely in the sandbox’s RAM using tmpfs. OverlayFS serves as orchestrator, directing reads to the EROFS base and writes to the in-memory tmpfs filesystem. Due to this, Blaxel sandboxes reserve, when possible, approximately 50% of the available memory for the tmpfs filesystem. More information on our implementation is available in this blog post. To avoid out-of-memory errors or if additional storage is required, one option is to add storage using volumes. However, this requires deleting and recreating the sandbox first. In addition, volumes are not as fast as the native in-memory filesystem.

Ports

The following ports are reserved by Blaxel’s system:
  • 443: This port hosts the main sandbox API and is exposed via HTTPS
  • 80: Reserved for system operations
  • 8080: Reserved for sandbox API functionality
You can expose specific non-reserved ports when creating a new sandbox by using the ports parameter. This allows you to access these ports from outside the sandbox.

Regions

Select the region where you want to deploy your sandbox. This parameter is required.

Labels

You can also add optional labels for sandboxes. Labels are specified as key-value pairs during sandbox creation.
// Create a new sandbox
const sandbox = await SandboxInstance.create({
  name: "my-sandbox",
  image: "blaxel/base-image:latest",   // public or custom image
  memory: 4096,   // in MB
  labels: { env: "dev", project: "my-project" }, // optional; labels
  region: "us-pdx-1"   // deployment region
});
You can use these labels for filtering sandboxes in the Blaxel CLI or Blaxel Console:
# Get sandboxes with specific label (e.g., env=dev)
bl get sandboxes -o json | jq -r '.[] | select(.metadata.labels.env == "dev") | .metadata.name'

Expiration

Blaxel supports automatic sandbox deletion based on specific conditions.

Retrieve an existing sandbox

To reconnect to an existing sandbox, simply provide its name:
import { SandboxInstance } from "@blaxel/core";

// Connect to existing sandbox
const sandbox = await SandboxInstance.get("my-sandbox");
Complete code examples demonstrating all operations are available on Blaxel’s GitHub: in TypeScript, in Python, and in Go.

Delete a sandbox

Delete a sandbox by calling:
  • the class-level delete() method with the sandbox name as argument, or
    import { SandboxInstance } from "@blaxel/core";
    
    // Delete sandbox using class-level method
    await SandboxInstance.delete("my-sandbox");
    
  • by calling the instance-level delete() method:
    import { SandboxInstance } from "@blaxel/core";
    
    // Get existing sandbox
    const sandbox = await SandboxInstance.get("my-sandbox");
    
    // Delete sandbox using instance-level method
    await sandbox.delete()
    

Upgrade a sandbox’s API

Every Blaxel sandbox includes a custom API binary, which is necessary for sandbox functionality like process management and file operations. It is possible to perform an in-place upgrade of this API without needing to recreate or restart the sandbox.
This feature is currently in beta and only available for sandboxes built or created with sandbox API v0.2.0 or later (sandboxes created after 2 Feb 2026). For sandboxes built or created earlier than this date/API version, in-place upgrade is not possible; the sandbox must be recreated to obtain the new API.
import { SandboxInstance } from "@blaxel/core";

// Connect to existing sandbox
const sandbox = await SandboxInstance.get("my-sandbox")

// Upgrade sandbox API to "latest"
await sandbox.system.upgrade({ version: "latest" })
You can find a list of available API versions in Blaxel’s public repository.

Connect to a sandbox with an interactive terminal

You can explore the contents of a sandbox with an interactive terminal. You can access this terminal in two ways:
  • From the Blaxel Console, by visiting the detail page for your sandbox in your web browser and selecting the Terminal tab: image.png
  • From your local host, by running:
    bl connect sandbox your-sandbox-name
    
    image.png
See tutorials and examples: Or explore the Sandbox API reference:

Sandbox API

Access the your sandbox with an HTTP REST API.