Your own cloud, starting with This Mac.

Cua Spaces runs sandboxes on computers you own or rent: this Mac, your other machines and the cloud accounts you connect. Here is how it compares with hosted sandbox services, with a source for every cell.

Checked 2026-10-24.

Only show differences

Free on this Mac; your cloud bills you directly Download

Hosted sandboxes, billed per second e2b.dev/pricing

Hosted sandboxes, billed per second daytona.io/pricing

Where it runs

On your own machines or cloud account

Yes

This Mac by default, your other computers, or the AWS, Google Cloud, Hetzner or Modal account you connect. Source

Yes

Self-host on one Linux machine with E2B Embed; BYOC on AWS, Google Cloud or Azure is Enterprise only. Source

Yes

Bring your own compute: your runners in custom regions, under Daytona's control plane. Source

Runs on your laptop

Yes

Local is the default: install, then create a sandbox on this computer. Source

Partial

The self-hosted stack needs a Linux machine with KVM; on a Mac it runs inside a Linux VM. Source

Unknown

No local mode in the maintained docs. Source

Regions

Wherever your machines are

This Mac, your other computers, or any region of a cloud you connect. Source

Partial

US by default; an EU cluster on request. Source

Yes

US and EU, plus custom regions. Source

Sandboxes

Operating systems

Yes

Linux, Windows Server 2022 and macOS (on Apple silicon). Source

Partial

Linux only. Source

Yes

Linux containers and VMs, and Windows VMs. macOS only through a partner. Source

Full desktop for computer use

Yes

Every Space is a full desktop you can watch, share and drive. Source

Yes

E2B Desktop: an Ubuntu desktop streamed over VNC. Source

Yes

Computer use with mouse, keyboard and screenshots on Linux and Windows. Source

Fork from a checkpoint

Yes

Checkpoint a sandbox, then fork one or many from it. Source

Yes

Snapshot a running sandbox (files and memory) and fork new sandboxes from it. Source

Yes

Linux VM sandboxes fork with files and memory; containers can't fork. Source

People and agents in one live session

Yes

Share a Space with your team as viewer or editor; each person gets a cursor. Sharing needs Teams. Source

Unknown

No shared live session found in E2B's docs. Source

Unknown

No shared live session found in Daytona's docs. Source

Agents and jobs

Start a coding agent from the CLI

Yes

cua agent run starts Claude Code, Codex, Gemini CLI and others in a sandbox. Source

Yes

e2b sbx create claude starts a sandbox with Claude Code. Source

Partial

daytona create makes sandboxes; no command that starts a coding agent. Source

Agents from the SDK

Partial

Spaces expose agent start, message and stop in every SDK binding. Source

Yes

Create a sandbox from the Claude template and run claude -p in it. Source

Partial

The SDK creates sandboxes and runs code; agents run through guides. Source

Durable agents

Yes

Durable runs resume after a crash; persistent agents keep memory across Spaces. Needs the Cua Spaces app. Source

Partial

Pause and resume keep files and memory; E2B isn't an agent runtime. Source

Partial

Sandboxes stop, archive or pause; no durable agent runtime. Source

Scheduled jobs

Yes

Jobs on your machines with cua run; routines on persistent agents. No general cron. Source

Unknown

No scheduler found in E2B's docs. Source

Unknown

No scheduler found in Daytona's docs. Source

MCP

Yes

cua mcp serves Spaces, sandbox and computer tools; sandboxes can call MCP servers. Source

Yes

An MCP gateway inside sandboxes. Source

Yes

A Daytona MCP server lets agents manage sandboxes. Source

Runs code written for other sandbox SDKs

Yes

With cua run --compat, code written for the E2B, Daytona or Modal SDK runs on your own machines. Source

Unknown

No compatibility with other SDKs claimed. Source

Unknown

No compatibility with other SDKs claimed. Source

Pricing

1 vCPU and 1 GiB, per sandbox-hour

$0/sandbox-hour on your own machines

In a cloud you connect, that cloud's own price. Source

$0.0666/sandbox-hour

$0.000014 per vCPU-second plus $0.0000045/GiB-second. Source

$0.0666/sandbox-hour

$0.0504 per vCPU-hour plus $0.0162/GiB-hour. Source

Worked out from each vendor's listed per-second or per-hour rates, before plan credits.

Plan fee

$0, or Pro at $18/month

Plans cover remote access through the relay; Teams is $30 per seat per month. Source

$0 or $150/month

Hobby is free with a one-time $100 credit; Pro is $150/month plus usage. Source

None shown

Usage-based, with $200 of free compute. Source

Billing step

Your cloud's own

No bill on your own machines; a connected cloud bills at its own step. Source

Per second

Billing stops when a sandbox is paused or killed. Source

Per second

Pay as you go. Source

Limits

Longest single run

No limit on your machines

Cloud Spaces stop after 8 hours unless you set another limit. Source

24 hours on Pro

1 hour on Hobby. Pausing and resuming starts the clock again. Source

Stops when idle

Containers stop after 15 minutes of inactivity by default. Source

Sandboxes at once

448 Spaces

Idle gVisor containers on one Mac Studio (M2 Max, 96 GB), 2026-10-25. Benchmark

100 on Pro

20 on Hobby. Add-ons raise the Pro limit. Source

Set by your tier

No fixed count; your tier's vCPU and memory pool bounds it. Source

Performance

Start time the vendor publishes

234.6 ms

gVisor container, p50, 2026-10-25. Benchmark

Unknown

No start-time figure on E2B's official pages. Source

Under 90 ms

Daytona's claim, from code to execution. Vendor's figure

Each vendor's own figure, measured their way. Not a like-for-like race.

Create to first command, measured by Cua the same way

234.6 ms

On the Mac itself, no network, p50, 2026-10-25. Benchmark

299 ms

Over the internet from the same Mac, p50, 2026-10-25. Benchmark

To be measured

Same method and day as the Cua run; the network paths differ, and each comparison page says how.

Licence

FSL-1.1-MIT (source-available)

The Spaces app and daemon. The CLI, SDK, Cua Driver and Lume are MIT. Source

Apache-2.0

SDKs and the runtime. Source

AGPL-3.0 (last public release)

The core moved to a private codebase in June 2026. SDKs are Apache-2.0; the CLI is AGPL-3.0. Source

Side by side

Each product's own example from its docs. Code shown here runs as written once you have an account and key; where an example needs more than that, there is a line and the link instead.

Start a sandbox and run a command

Cua Spaces

# Install Cua Spaces from cua.ai/download
cua sb create linux --name dev
cua sb exec dev "uname -a"
cua sb rm -f dev

From cua.ai/docs/cua-cli/quickstart

E2B

pip install e2b-code-interpreter python-dotenv

# main.py
from dotenv import load_dotenv
load_dotenv()
from e2b_code_interpreter import Sandbox

sbx = Sandbox.create() # Creates a persistent sandbox session
execution = sbx.run_code("print('hello world')") # Execute Python inside the sandbox
print(execution.logs)

files = sbx.files.list("/")
print(files)

From docs.e2b.dev/quickstart

Daytona

pip install daytona

# Import the Daytona SDK
from daytona import Daytona, DaytonaConfig

# Define the configuration
config = DaytonaConfig(api_key="YOUR_API_KEY") # Replace with your API key

# Initialize the Daytona client
daytona = Daytona(config)

# Create the Sandbox instance
sandbox = daytona.create()

# Run code
response = sandbox.process.code_run('print("Hello World")')
print(response.result)

From daytona.io/docs/en

Modal Sandboxes

# uv pip install modal
import modal

sb_app = modal.App.lookup("my-app", create_if_missing=True)
sb = modal.Sandbox.create(app=sb_app)

p = sb.exec("python", "-c", "print('hello')", timeout=3)
print(p.stdout.read())

sb.terminate()

Assembled from modal.com/docs/guide/sandboxes

Vercel

npm install @vercel/sandbox dotenv @types/node tsx typescript

// index.ts
import { config } from 'dotenv';
config({ path: '.env.local' });
import { Sandbox } from '@vercel/sandbox';

async function main() {
  const sandbox = await Sandbox.create();
  const result = await sandbox.runCommand('echo', ['Hello from Vercel Sandbox!']);
  console.log(await result.stdout());
}

main().catch(console.error);

// first: vercel link && vercel env pull   (auth); run: pnpm tsx index.ts

From vercel.com/docs/sandbox/quickstart

Cloudflare

npm create cloudflare@latest -- sandbox-linux --category=hello-world --type=hello-world --lang=ts --no-deploy --no-git --no-agents

// wrangler.jsonc
{
  "$schema": "node_modules/wrangler/config-schema.json",
  "name": "sandbox-linux",
  "main": "src/index.ts",
  "compatibility_date": "2026-10-24",
  "observability": { "enabled": true },
  "upload_source_maps": true,
  "containers": [{ "class_name": "MyContainer", "scheduling_policy": "durable_object" }],
  "durable_objects": { "bindings": [{ "class_name": "MyContainer", "name": "MY_CONTAINER" }] },
  "exports": { "MyContainer": { "type": "durable-object", "storage": "sqlite" } }
}

// src/index.ts
import { DurableObject } from "cloudflare:workers";

export class MyContainer extends DurableObject {
  async exec(argv: string[]) {
    const container = this.ctx.container;
    if (!container) {
      throw new Error("No container is configured");
    }
    if (!container.running) {
      container.start({
        image: "cloudflare/debian-trixie",
        entrypoint: ["sleep", "infinity"],
        enableInternet: false,
      });
    }
    const process = await container.exec(argv);
    const output = await process.output();
    return {
      stdout: new TextDecoder().decode(output.stdout),
      exitCode: output.exitCode,
    };
  }
}

export default {
  async fetch(request, env) {
    const { argv } = await request.json();
    const sandbox = env.MY_CONTAINER.getByName("sandbox");
    return Response.json(await sandbox.exec(argv));
  },
};

Assembled from developers.cloudflare.com/sandbox/get-started/index

Start a durable agent

Cua Spaces

# Install Cua Spaces from cua.ai/download
cua sb create linux --name dev
cua agent create ada --harness claude-code --in local:dev --env-from-host ANTHROPIC_API_KEY
cua agent tell ada "what did you learn yesterday?"
# crash-resumable one-shot instead: cua agent run --durable --on auto claude-code "Fix the failing tests in /work"

Assembled from cua.ai/docs/cua-cli/reference/cli/agents

E2B

import os
from e2b import Sandbox

sandbox = Sandbox.create("claude", envs={
    "ANTHROPIC_API_KEY": os.environ["ANTHROPIC_API_KEY"],
})

result = sandbox.commands.run(
    'claude --dangerously-skip-permissions -p "Create a hello world HTTP server in Go"',
)

print(result.stdout)

# Pause: filesystem + memory kept, no TTL (docs.e2b.dev/sandbox/persistence.md)
sandbox.pause()
# Resume later
sandbox.connect()

Assembled from docs.e2b.dev/agents/claude-code

Daytona

Not supported: no durable agent runtime in Daytona's docs. Docs

Modal Sandboxes

No durable agent runtime: a sandbox lives up to 24 hours, and snapshots keep its files. Docs

Vercel

WorkflowAgent from @ai-sdk/workflow inside a 'use workflow' function; the docs' example needs tool steps defined elsewhere. Docs

Cloudflare

npm create cloudflare@latest -- --template cloudflare/agents-starter

From developers.cloudflare.com/agents/getting-started/quick-start/

Fork N sandboxes

Cua Spaces

# Install Cua Spaces from cua.ai/download
cua sb create linux --name base
cua sb checkpoint base world
cua sb fork-many world --count 3

From cua.ai/docs/cua-cli/reference/cli/sandboxes

E2B

from e2b import Sandbox

sandbox = Sandbox.create()

forks = sandbox.fork(count=3)

for fork in forks:
    if isinstance(fork, Sandbox):
        print('Forked sandbox:', fork.sandbox_id)

From docs.e2b.dev/sandbox/fork

Daytona

One Linux VM sandbox per sandbox.fork() call; containers can't fork. Docs

Modal Sandboxes

import modal

app = modal.App.lookup("sandbox-fork-example", create_if_missing=True)

sb = modal.Sandbox.create(app=app)
p = sb.exec("bash", "-c", "pip install numpy && echo 'setup done' > /status")
p.wait()

image = sb.snapshot_filesystem()
sb.terminate()

# Start multiple Sandboxes from the same snapshot
sb2 = modal.Sandbox.create(image=image, app=app)
sb3 = modal.Sandbox.create(image=image, app=app)

# Each fork starts from the snapshotted state
assert sb2.exec("cat", "/status").stdout.read().strip() == "setup done"
assert sb3.exec("cat", "/status").stdout.read().strip() == "setup done"

From modal.com/docs/guide/sandbox-snapshots

Vercel

Sandbox.fork() starts one new sandbox from another sandbox's filesystem snapshot. Docs

Cloudflare

Container snapshots keep the filesystem only; restore one into each Durable Object you start. No fork-N call. Docs

Schedule a job

Cua Spaces

# Install Cua Spaces from cua.ai/download
cua sb create linux --name dev
cua agent create ada --harness claude-code --in local:dev --env-from-host ANTHROPIC_API_KEY
cua agent routine add ada --title "Inbox sweep" --prompt "Triage new issues" --every 60
cua agent routine add ada --title "Morning" --prompt "Plan the day" --daily 08:00
cua agent routine ls ada

Assembled from cua.ai/docs/cua-cli/reference/cli/agents

E2B

Not supported: no scheduler in E2B's docs. Docs

Daytona

Not supported: no scheduler in Daytona's docs. Docs

Modal Sandboxes

# pip install modal
# heavy.py
import modal

app = modal.App()

# runs at 8 am (UTC) every Monday
@app.function(schedule=modal.Cron("0 8 * * 1"))
def perform_heavy_computation():
    ...

# deploy: modal deploy --name daily_heavy heavy.py

Assembled from modal.com/docs/guide/cron

Vercel

// vercel.json
{
  "crons": [
    {
      "path": "/api/hello",
      "schedule": "0 5 * * *"
    }
  ]
}

// app/api/hello/route.ts
export function GET(request: Request) {
  return new Response('Hello from Vercel!');
}

From vercel.com/docs/cron-jobs/quickstart

Cloudflare

Workers Cron Triggers call a scheduled() handler; Agents can also call this.schedule(). Docs

Measured head to head

Runs of both products, measured the same way on the same day. Each page states where each side ran and its network path.

Does a Cua Space start faster than an E2B sandbox?Cua Spaces (This Mac) 234.6 ms, E2B 299 ms; 2026-10-25
Does a Cua Space start faster than a Modal Sandbox?Cua Spaces (This Mac) 234.6 ms, Modal Sandboxes 690.7 ms; 2026-10-25
Does a Cua Space start faster than a Daytona sandbox?To be measured
Does E2B SDK code run unchanged on Cua Spaces?To be measured

Sources

Every cell cites the vendor's own page, checked on the date shown. Unknown means no official page we found says it.

Where a vendor's own pages disagree with each other, neither number is shown.

Cua Spaces facts and examples are for Cua Spaces 0.15.0, which includes the cua 0.9.0 command line. The examples use that command line because the standalone cua 0.9.0 package is not on PyPI yet.

Prices per hour for 1 vCPU and 1 GiB are worked out from each vendor's listed rates. Plan credits and free tiers are not subtracted. Measured Cua numbers link to their benchmark page, with the method and raw data. Compare the clouds Spaces run on.

Checked 2026-10-24:

Cua Spaces

E2B

Daytona

Modal Sandboxes

Vercel

Cloudflare