Butter currently describes bVisor as its local runtime. The official repository marks bVisor an early proof of concept and says it should not yet be used in production. Read the source ↗

Self-managed runtimes / Butter alternative

A bVisor alternative when the agent needs a durable remote computer

Butter’s current site points to bVisor, a local embedded bash runtime. It intercepts selected Linux system calls and overlays writes on the host filesystem. That deployment model differs from a hosted, durable per-user computer; choose the model before comparing sandbox features or prices.

Start building Compare capabilities ↓

Reviewed 2026-10-18 · Published by the Sandbox0 team

When Butter fits

bVisor fits experiments that need local command execution inside an application, immediate access to host-provided dependencies, and no remote-service round trip. Its repository explicitly calls it an early proof of concept that should not yet be used in production.

When to consider Sandbox0

Consider Sandbox0 for hosted agent execution with a durable writable RootFS, lifecycle management, online filesystem growth, and supported file operations while compute remains paused. Moving to a remote runtime changes latency, credentials, network reachability, and where host files are available.

Capabilities

Butter and Sandbox0: what persists?

Feature comparison with documentation and verification status
Capability	Butter	Sandbox0
Environment and runtime lifetime	ButterNot established in this review	Sandbox0ttl and hard_ttl default to 0 (disabled). Configure idle pause and deletion policies for the same persistent sandbox identity; an idle running sandbox still accrues compute charges.Read documentation →
Persistent files	ButterA sandbox-local copy-on-write overlay is described; managed durable retention across application or host loss is not established.View evidence ↗	Sandbox0The writable RootFS survives successful checkpoints, including software, system configuration, dependencies, and user data.Read documentation →
Whole RootFS	ButterHost read-through and an overlay do not establish an independently retained complete cloud RootFS.View evidence ↗	Sandbox0Persistence extends beyond /workspace to paths such as /usr/local, /etc, and /home. Runtime tmpfs and virtual filesystems are excluded.Read documentation →
Release compute, keep state	ButterNo managed compute-release and returning-sandbox pause/resume contract is established by this proof of concept.View evidence ↗	Sandbox0Pause compute between tasks; resume on available capacity. Default resume starts fresh processes from the saved filesystem.Read documentation →
Memory and process state	ButterThe reviewed runtime does not establish a user-facing execution-memory checkpoint contract.View evidence ↗	Sandbox0Experimental memory checkpoints can preserve compatible process state. Use memory: true on both pause and resume on a compatible deployment. A filesystem checkpoint alone does not preserve running processes.Read documentation →

Online RootFS growth

On growth-enabled images, Sandbox0 automatically expands the writable RootFS as free space runs low, within a configured sparse logical ceiling up to 64 TiB. Agent processes keep running. Growth is enabled in the qualified Cloud region; confirm activation for other regions. Existing images and snapshots retain their captured storage geometry. The ceiling is logical capacity, not preallocated host disk.

The reviewed host overlay does not establish managed automatic online expansion of an independently durable complete RootFS. Host disk capacity and its lifecycle remain the application operator’s responsibility.

Files while compute is paused

Sandbox0's Files API reads persistent files without resuming compute. Filesystem-only pauses also permit edits; retained-memory pauses are read-only and reject mutations with 409. SSH, SFTP, file watching, and runtime-only mounts require running compute.

See paused file operations →

A host-backed overlay is not a regionally durable computer

bVisor reads through to the host filesystem and copies files opened for writing into a sandbox-local overlay. That makes host tools available without building an image, but the reviewed design does not establish regional storage, recovery after losing the host, or a returning cloud-computer identity. Decide which state must survive the application and the underlying host.

Source 1 ↗

An embedded application kernel has its own compatibility boundary

The repository lists virtualized, passed-through, blocked, and unimplemented Linux calls. It currently targets Linux on ARM and x86, with a TypeScript wrapper, while Python and CLI support are planned. For example, its documented blocked server-socket operations matter if an agent expects to launch a listening development service. Validate required behavior against the reviewed revision.

Source 1 ↗

Software licensing and hosted runtime charges are different costs

bVisor is Apache-2.0 software run on hardware the application controls. The public Butter page does not provide a managed CPU/RAM rate card. Budget host capacity, storage, packaging, monitoring, and operations separately; an open software license is not a promise of free hosted compute.

Source 1 ↗Source 2 ↗

Pricing

Compare billing models, then price your workload

CPU allocation, memory, billing minimums, disk, plan fees, and supported workload differ. These meters are not equal-performance machine quotes. Confirm region, resource units, and included allowances before estimating a total.

Butter

Pricing reviewed 2026-10-18

bVisor software: Apache-2.0 license; run on your own infrastructure; This is software licensing, not an included cloud-compute allowance.; Rate source ↗
Host compute and retained storage: Determined by your machine or infrastructure provider; Rate source ↗
Managed Butter rate card: Public managed service rate not established; Rate source ↗

Compare total operating responsibility and required functionality before unit costs. The repository’s local startup example is not a verified end-to-end hosted latency comparison, and no equal-throughput savings claim follows from the license.

Check current Butter pricing ↗

Sandbox0

$0.015/GiB-hour compute (billed by the second at approximately $0.000004167/GiB-second), plus $0.02/GiB-month of retained incremental RootFS and memory checkpoint data. Shared base images and platform recovery retention are excluded; paused sandboxes accrue storage charges only.

Compute / GiB-hour: $0.015
Retained data / GiB-month: $0.02
Paused compute: $0.00

A 4 GiB agent, 100 running hours

$6.00 compute

4 GiB × 100 hours, billed by the second. Keeping 20 GiB of billable incremental data for a full billing month adds $0.40. CPU is derived from memory by the platform; choose a tier that fits your workload.

Understand storage billing →

Before migrating from Butter

Inventory host files, dependencies, supported system calls, local network assumptions, and overlay outputs that must outlive the local application.
Build a target image and replace embedded command calls with remote Sandbox0 command/file integration, explicitly transferring required inputs and credentials.
Validate workload compatibility, repeated system state, growing outputs, paused file access, and remote execution latency and operating cost.

Common questions

Is Sandbox0 a drop-in Butter replacement?

Evaluate API compatibility and product scope. These products serve different core workflows, so a change may require a different architecture.

Does keeping files also keep a running agent?

Filesystem state and volatile process state are separate. Sandbox0 requires explicit compatible memory checkpoints to preserve running processes; its default filesystem resume starts fresh processes.

Sources and review scope

The Boat team's Battleships directory is the discovery source. References below describe the product and plan discussed on this page. Check current availability, regional terms and billing units before migrating. Where the cited material does not establish a capability or price, the comparison identifies that uncertainty.

Battleships research record ↗github.com/butter-dot-dev/bVisor ↗www.butter.dev/ ↗Sandbox0 RootFS capacity →

Related comparisons

Cedana vs Sandbox0 →ScitiX Agent Sandbox vs Sandbox0 →Self-operated bare-metal sandbox fleet vs Sandbox0 →Tart Virtualization + Orchard vs Sandbox0 →Agency Tool Company vs Sandbox0 →Agent 37 vs Sandbox0 →