Product
Everything your agent's computer can do
Each TaskCloud sandbox is a full Firecracker microVM that keeps its disk, pauses with its memory and wakes on the next request. Below is every capability in the beta, with the API call behind it.
Persistent VMs, not containers
Every sandbox runs its own Linux kernel in a Firecracker microVM, with Ubuntu 24.04, root, systemd and Docker inside. Isolation uses the Firecracker jailer, cgroups and a network namespace per VM. The disk persists for the life of the sandbox, across pauses.
| Size | vCPU | RAM | Disk | Active hour |
|---|---|---|---|---|
small | 2 | 4 GB | 20 GB | $0.015 |
default | 4 | 8 GB | 50 GB | $0.030 |
large | 8 | 16 GB | 100 GB | $0.060 |
Pause and resume with memory
Pause writes RAM, device state and disk to a snapshot and releases the vCPUs. Processes, open windows, shells and browser tabs come back as they were. A paused sandbox costs $0 in compute; its snapshot is stored free for 30 days.
Sandboxes pause themselves after 5 idle minutes by default. Any HTTP request to a port, SSH connection or API call wakes them.
const sbx = await client.sandboxes.create({
auto_pause: { enabled: true, idle_timeout_seconds: 300 },
});
await sbx.pause(); // state: paused, $0 compute
await sbx.resume(); // usually not needed: any call wakes itFork a running VM
Fork copies a live sandbox, memory included, into new sandboxes that continue from the same moment. Branch an agent to try several approaches, or prepare an eval environment once and fan it out. A single call creates up to 50 copies (more on request), all or nothing; with priority: "batch" they get the night discount.
// 50 identical environments for 50 rollouts
const forks = await sbx.forkMany(50, { priority: "batch" });
# Python
forks = sbx.fork_many(50, priority="batch")
# CLI
taskcloud fork $ID --count 50 -qDesktop streaming and computer use
The desktop template runs XFCE with Chromium and Firefox. Stream it to any browser through a signed link with a TTL, optionally read-only, so people can watch or take over. Agents drive the same screen with GET /screenshot and POST /input (mouse and keyboard). Rendering is software-only; there are no GPUs.
const { url } = await sbx.desktop.stream({ ttl_seconds: 600, read_only: true });
const shot = await sbx.desktop.screenshot({ format: "png" });
await sbx.desktop.input({ actions: [
{ action: "left_click", coordinate: [640, 412] },
] });Terminal and exec
Run commands synchronously, in the background with a handle you can stream, kill or feed stdin, as a server-sent event stream, or as an interactive PTY over WebSocket. At least 10 commands can run in parallel in one VM.
const dev = await sbx.exec({ command: "npm run dev", background: true });
const term = await sbx.pty.connect({
cols: 120, rows: 40,
onData: (bytes) => process.stdout.write(bytes),
});
term.write("htop\r");Files
Read and write single files, list directories, upload and download whole trees as archives, get signed upload and download URLs, and watch a directory for changes as an event stream. A watch survives pause and resume.
await sbx.files.write("/home/user/app/.env", "PORT=3000\n", { mode: "0600" });
const pkg = await sbx.files.readText("/home/user/app/package.json");
for await (const ev of sbx.files.watch("/home/user/app/src")) {
console.log(ev.type, ev.path);
}Ports, preview URLs and SSH
Expose any port over HTTPS to show a live app preview, privately behind an access token or publicly. Sandbox traffic lives on its own domain, taskhost.cloud, separate from our website and API. SSH goes through our gateway with your public key; both wake a paused VM. Egress allowlists are planned.
const port = await sbx.ports.expose({ port: 3000, visibility: "public" });
console.log(port.url); // https://<short_id>-3000.taskhost.cloud
# SSH from your laptop (sends ~/.ssh/*.pub)
taskcloud ssh $IDTemplates and snapshots
Build a template from any Docker/OCI image (linux/amd64): we turn it into a VM root filesystem, boot it, wait for your ready check and keep a RAM snapshot, so new sandboxes start warm. Or snapshot a configured sandbox, name it, and start new sandboxes from it. Official templates, ready in one call: base, python, node, browser, coding-agent, jupyter and desktop.
taskcloud template create --name agent-env --image ghcr.io/acme/agent-env:1.4
const snap = await sbx.snapshots.create({ name: "after-npm-install" });
const copy = await client.sandboxes.create({ snapshot_id: snap.id });Webhooks
Get a signed HTTP call when a sandbox becomes ready, pauses, resumes, fails or is deleted, and when usage crosses a spend-limit or plan threshold. Use them to update your UI, re-bill your own users or stop runaway spend.
await client.webhooks.create({
url: "https://example.com/hooks/taskcloud",
events: ["sandbox.paused", "sandbox.resumed", "usage.threshold"],
});MCP server
Let Claude Code, Cursor or any MCP client create and drive its own sandboxes: create, pause, resume, fork, exec, read and write files, expose ports, stream the desktop, take screenshots and send input. Run it locally over stdio or self-host the HTTP server; every tool call is limited by the scopes of the API key you give it. The hosted endpoint mcp.task.cloud is not live yet.
claude mcp add taskcloud --env TASKCLOUD_API_KEY=$TASKCLOUD_API_KEY -- npx -y @taskcloud/mcp
# create_sandbox list_sandboxes get_sandbox pause_sandbox
# resume_sandbox fork_sandbox delete_sandbox exec
# read_file write_file list_files expose_port
# desktop_stream_url screenshot computer_inputBatch pricing at night, and always-on
Jobs that can wait (evals, CI, data processing) cost half when they run in the EU night window, 22:00–07:00 CET, or when you create them with priority: "batch"; they may queue until capacity is free. Agents that must never sleep can switch to always-on: a flat $19.90 per month for a default VM instead of the hourly price.
// Half price, may wait in "queued"
const job = await client.sandboxes.create({ size: "small", priority: "batch" });
// Never pauses, flat monthly price
await sbx.update({ always_on: true });Teams, controls and the web console
Today: API keys with scopes and per-label restrictions, monthly spend limits with alerts, a usage API to re-bill your own users, and per-second usage per sandbox.
Coming with the web console: teams and roles, every sandbox with its state and cost in one list, and a live terminal and desktop right in the browser. SSO and audit logs are on the roadmap.
Start with 20 free hours
A 4 vCPU / 8 GB VM, no card. Then $0.030 per active hour, billed per second, $0 while paused.