Skip to main content

Not just a sandbox. A real computer for every agent

Your agent gets a full Linux machine, not a throwaway runtime: a terminal, a live desktop, a browser, and a public URL, with a disk that is still there after it stops.

Start freeRead the quickstart
1# pip install -U celesto
2# celesto auth login   (or export CELESTO_API_KEY=...)
3from celesto import Computer
4
5computer = Computer(provider="cloud", lifetime="persistent",
6                    template_id="coding-agent")
7result = computer.run("git --version")
8print(result.stdout)
9
10computer.stop()  # the disk is kept for next time

Access

One sandbox. Four ways in.

Open a shell, watch the screen, hand your agent a browser, or share what it built.

curie · cloud · running

A live shell from the console, or from your own terminal.

$ celesto computer create --cloud --name curie
$ celesto computer ssh curie --cloud
ohm@curie:~$ git clone https://github.com/acme/api && cd api
ohm@curie:~/api$ pnpm install && pnpm test
✓ 128 tests passed
ohm@curie:~/api$
Connected over a secure WebSocket · no SSH keys or open portsAlso in the console: Terminal

Stop it tonight. Pick up tomorrow.

Stop a sandbox when the work is done and pay nothing for compute. Start it again with your files, packages, and workspace where you left them.

  1. runningbilled per hour
  2. stoppeddisk kept 30 days
  3. runningfiles and packages intact
Persistent disk
The root disk survives every stop and start.
CelestoFS workspace
Durable workspace storage that is not limited by the sandbox's disk size.
Persistent home
Set persistentHome when you create a sandbox to keep /home/ohm, dotfiles and all, across stop and start.

Safe to run anything.

Let agents install, compile, and execute without touching your machine.

Its own virtual machine

Every sandbox runs its own kernel on KVM. Code in one sandbox cannot see another.

Internet off in one option

Create with networkPolicy set to off to block outbound connections for untrusted code.

Keys scoped to one org

Each API key belongs to one organization. The MCP server signs in with OAuth and asks for scopes.

Root inside, nothing outside

Agents get sudo in their sandbox and nothing on your laptop or servers.

Everything your agent needs to run reliably.

Production sandboxes with the primitives that make long-running agents practical — forking, streaming, and instant recovery out of the box.

See every sandbox feature →
abc01 create02 pauseresume03 forkrunningpausedrunning04 volume/data /models /cache
  1. 01

    Instant boot

    Cold start to running in under 2 seconds. No waiting for provisioning or image pulls.

    cold start < 2 s

  2. 02

    Pause & resume

    Suspend sandboxes when idle and resume in milliseconds. Pay only for active compute.

    processes kept intact

  3. 03

    Forking

    Branch a running sandbox into parallel copies. Test variants, roll back, or fan out work without reprovisioning.

    fork → a · b · c

  4. 04

    Persistent storage

    Attached volumes survive restarts and snapshots, so your agent's data is always where it left off.

    /data /models /cache

  5. 05

    Browser use

    A full browser inside the sandbox. Navigate, click, fill forms, and extract data, headless or streamed live.

    CDP · VNC

  6. 06

    CLI & SDK access

    Full programmatic control. Execute commands, stream output, and manage sandboxes from code or terminal.

    celesto computer run

Open source

Open source at the core.

Celesto sandboxes run on celesto, our Apache-2.0 microVM package. Read the code, run sandboxes on your own machines, and move the same code to Celesto Cloud when you need it remote.

Star on GitHub1k starsCelestoAI/celesto
pip install celestoApache-2.0
1from celesto import Computer
2
3# On your machine (needs local virtualization)
4local = Computer()
5
6# In Celesto Cloud (needs an API key)
7cloud = Computer(provider="cloud")
8
9# Same API on both
10print(cloud.run("uname -a").stdout)

Works with the agent you already use.

Sizes

Pick the machine. Pay by the hour.

Six sizes, billed only while a sandbox runs. The $5 trial credit covers Micro.

Sandbox sizes and hourly prices in USD
SizevCPURAMDiskPer hour
Micro12 GB20 GB$0.015
Small14 GB25 GB$0.020
Standard24 GB30 GB$0.030
Memory28 GB40 GB$0.040
Large416 GB60 GB$0.080
XL832 GB100 GB$0.160
See full pricing →

Every feature

All 23 features, searchable.

Ask the way you would ask a teammate. Each answer shows the command or button that uses it.

Try

Get inside

  • Terminal in the browser

    Open a live shell on any running sandbox from the console.

    Console → TerminalConsole

  • Terminal from your laptopDocs for Terminal from your laptop ↗

    An interactive shell from your own terminal, with no SSH keys to manage.

    celesto computer ssh my-box --cloudCLISDK

  • Desktop viewDocs for Desktop view ↗

    Watch or take control of the sandbox's screen, live. On the browser templates.

    Console → Display · computer.display()ConsoleSDK

  • Browser for agentsDocs for Browser for agents ↗

    A Chromium browser your code drives over CDP with Playwright or Puppeteer.

    computer.browser()SDK

Run code

  • Run any commandDocs for Run any command ↗

    Run a command and get its output and exit code. 30 seconds by default, up to 5 minutes with timeout.

    computer.run("npm test", timeout=300)CLISDKMCP

  • Streaming outputDocs for Streaming output ↗

    Read stdout and stderr line by line while a long command runs.

    computer.run_stream("npm test")SDK

  • Root access

    Full sudo on a real Linux machine. Install anything with apt, pip, or npm.

    sudo apt install …ConsoleCLISDKMCP

  • Docker support

    Run Docker containers inside your sandbox.

    docker run --rm hello-worldConsoleCLISDKMCP

  • Command history

    See every command a sandbox ran, with its exit code.

    Console → sandbox detailsConsoleSDK

Share and connect

  • Public preview URLsDocs for Public preview URLs ↗

    Turn a port into an HTTPS link anyone can open. Up to 4 ports per sandbox.

    celesto computer port publish my-box --port 3000ConsoleCLISDKMCP

  • Internet on or offDocs for Internet on or off ↗

    Cut outbound internet for untrusted code with one option in the TypeScript SDK.

    networkPolicy: { mode: "off" }SDK

Keep your work

  • Stop and startDocs for Stop and start ↗

    Stop a sandbox when you're done and start it later with files and installed packages intact.

    computer.stop() · computer.start()ConsoleCLISDKMCP

  • Persistent disk and homeDocs for Persistent disk and home ↗

    The disk survives every stop. Stopped disks are kept for 30 days.

    AutomaticConsoleCLISDKMCP

  • CelestoFS workspaceDocs for CelestoFS workspace ↗

    Durable workspace storage that is not limited by the size of the sandbox's disk.

    Mounted automaticallyConsoleCLISDKMCP

Pick the machine

  • Six sizes

    From 1 vCPU · 2 GB at $0.015/hour to 8 vCPU · 32 GB. Billed only while running.

    Computer(provider="cloud", vcpus=4, ram_mb=16384)ConsoleSDK

  • Ready-made templatesDocs for Ready-made templates ↗

    Start from a clean Ubuntu box, a coding-agent image with Git, Python, and Node, or a browser image.

    Computer(provider="cloud", template_id="coding-agent")ConsoleSDK

  • Its own virtual machine

    Every sandbox is a separate KVM virtual machine, not a container sharing a kernel.

    Every sandboxConsoleCLISDKMCP

  • Usage charts

    CPU, memory, and disk usage for each sandbox over the last hour or day.

    Console → sandbox detailsConsole

Plug into your agents

Asked often.

Can I run Docker in a Celesto sandbox?

Yes. Celesto sandboxes support Docker, so you can run containers inside your sandbox from the terminal or through commands sent by the CLI, SDK, or MCP server.

Can I open a terminal in a Celesto sandbox?

Yes. Click Terminal on a running sandbox in the Celesto console, or run celesto computer ssh NAME --cloud from your own terminal.

Is celesto computer ssh real SSH?

For cloud sandboxes it opens an interactive shell over a secure WebSocket, so you need no SSH keys and no open port 22. Use it the way you would use an SSH session.

Can I see the sandbox's screen?

Yes, on the browser templates. Console → Display shows the live desktop, read-only or with mouse and keyboard control. From code, computer.display() in Python or createDisplayConnection() in TypeScript returns a connection URL.

Can my agent drive a web browser?

Yes. Create a sandbox from the browser-agent template and call computer.browser() in Python or createBrowserConnection() in TypeScript. Connect Playwright or Puppeteer to the returned CDP URL.

Can I expose a web server from a sandbox?

Yes. Publish any port from 1024 to 65535 and get a public HTTPS URL. Each sandbox can publish up to 4 ports, from the console, CLI, SDK, or MCP.

Do files survive when a sandbox stops?

Yes. The disk, installed packages, and the CelestoFS workspace survive stop and start, and a stopped disk is kept for 30 days. Running processes end when the sandbox stops.

Can I turn off internet access?

Yes. Create the sandbox with networkPolicy: { mode: "off" } in the TypeScript SDK to block outbound connections for untrusted code.

How do Claude Code and other agents use Celesto?

Connect them to the hosted MCP server at https://mcp.celesto.ai/mcp. Its tools create, start, stop, and delete sandboxes, run commands, and publish ports. In Claude Code, run claude mcp add --transport http celesto https://mcp.celesto.ai/mcp.

Is Celesto open source?

Yes. Celesto sandboxes run on celesto, our Apache-2.0 microVM package at github.com/CelestoAI/celesto. The same Python package runs a sandbox on your machine with Computer() or in Celesto Cloud with Computer(provider="cloud").

How is each sandbox isolated?

Every sandbox is its own KVM virtual machine with its own kernel, so code in one sandbox cannot see another. It is not a container on a shared kernel.

What does a sandbox cost?

Sandboxes are billed only while running, from $0.015 per hour for Micro (1 vCPU, 2 GB). New accounts get a one-time $5 trial credit with no card required.