Private beta · EU-hosted

A computer for every agent. Pay only while it works.

Give each AI agent its own persistent Linux VM. When it goes quiet, the VM pauses with its memory intact and compute billing drops to $0. The next request brings it back, exactly where it left off.

Free plan: 20 hours of default, 2 concurrent VMs, no card.

  • $0.030per active hour, 4 vCPU / 8 GB
  • $0compute while paused
  • < 1 sresume with RAM (target p95 < 800 ms)
  • ×50fork a running VM in one call
The life of one agent VM: it is created, does work and is billed per second, goes idle, pauses with RAM and disk snapshotted at $0 compute, resumes with memory restored on the next request, and is forked into 50 copies. Use the step buttons to show each stage.
sbx_7f3k2a · default · 4 vCPU / 8 GB creating
Compute
$0.030/h
Memory
booting
VMs
1
Illustration. Latency figures are targets.

API first

From zero to 50 forked agents in a few lines

Typed SDKs for TypeScript and Python built against our OpenAPI spec, a single-binary CLI and an MCP server for agents that drive the VM themselves.

  • Full VM: Ubuntu 24.04, root, systemd and Docker.
  • Pause & resume with RAM intact; paused = $0 compute.
  • Fork a running VM, memory included, 1–50 copies per call.
  • Preview URLs for any port on taskhost.cloud.
import { Client } from "@taskcloud/sdk";
const client = new Client(); // reads TASKCLOUD_API_KEY

// A full VM that pauses itself after 5 idle minutes
const sbx = await client.sandboxes.create({
  template: "base", size: "default",
  auto_pause: { enabled: true, idle_timeout_seconds: 300 },
});

const run = await sbx.exec("npm ci && npm test");
console.log(run.exit_code, run.stdout);

await sbx.pause();  // RAM + disk snapshot, $0 compute
await sbx.resume(); // same processes, same PIDs

// 50 copies of the running VM, memory included (all or nothing)
const forks = await sbx.forkMany(50);

const port = await sbx.ports.expose({ port: 3000, visibility: "public" });
console.log(port.url); // https://<short_id>-3000.taskhost.cloud

Field names follow the OpenAPI spec and are linted in CI. TypeScript · Python · CLI · MCP

How it works

Snapshot the memory, not just the disk

Most platforms keep an idle VM running (and billing) or stop it and boot it again later. TaskCloud freezes the whole machine instead, then thaws it on the next request.

  1. 01 · CREATE

    A full VM per agent

    A Firecracker microVM with its own kernel, from a built-in template, your snapshot or any OCI image.

    POST /sandboxes {"template": "base"}
  2. 02 · WORK

    Billed per second

    Exec, files, PTY, ports, SSH and a live desktop. You pay for the seconds the VM runs.

    POST /sandboxes/{id}/exec
  3. 03 · PAUSE

    Idle? $0 compute

    After 5 idle minutes (configurable) RAM and disk are snapshotted and the vCPUs are released.

    auto_pause: {"idle_timeout_seconds": 300}
  4. 04 · WAKE

    Back with its memory

    An HTTP request, SSH session or API call restores it in under a second (target p95 < 800 ms).

    GET https://<short_id>-3000.taskhost.cloud

Why pause beats reboot: RAM snapshots vs disk snapshots →

What every sandbox gets

A real computer, not a container with a timer

Everything below is in scope for the beta. See every capability →

FIRECRACKER · UBUNTU 24.04

Full VM with root

Own kernel, systemd and Docker inside. Isolated with jailer, cgroups and a network namespace per VM.

TARGET P95 < 800 MS

Pause with memory

Processes, open windows and sessions survive the pause. Auto-pause when idle, wake on request.

1–50 COPIES PER CALL

Fork a running VM

Clone a live VM with its memory to branch an agent's work or fan out identical eval environments.

1920×1080 · KASMVNC

Desktop & computer use

Stream an XFCE desktop to the browser and drive it via screenshot and input APIs. Learn more

https://<short_id>-<port>.taskhost.cloud

Preview URLs & SSH

Expose any port over HTTPS for app previews. SSH through our gateway. Terminal over WebSocket.

TS · PYTHON · CLI · MCP

Built for agents

SDKs built against the OpenAPI spec, a CLI, an MCP server, signed webhooks and llms.txt.

Real cost, not list price

1,000 agent VMs, active 10% of the time

Most agent VMs sit idle most of the day. With per-second billing and $0 while paused, your bill follows the work, not the number of sign-ups.

  • TaskCloud~$2,190
  • E2B~$24,163

Monthly compute at list prices for 4 vCPU / 8 GB per hour, per battleships.dev (October 2026): TaskCloud $0.030 and E2B $0.331 for 73 active hours. Storage and plan fees excluded. Providers that bill while a VM runs and stop it on a timer (boat.dev) depend on your auto-stop setting; model that in the bill calculator. Full table with Daytona and Modal on the compare page.

One agent VM, one day, 15-minute slots billed: 2.5 h of 24 h
Running: billed per secondPaused: RAM + disk kept, $0 compute
This VM, this day
2.5 h × $0.030 = $0.075
Batch at night
−50% in the EU night window (22:00–07:00 CET) or with priority: "batch"
Never pauses?
Always-on: $19.90/month for a default VM

Console

Watch every agent's machine from the browser Coming soon

A web console for teams: every sandbox with its state and cost, a live terminal and the desktop stream in one tab, plus teams and roles. Until it ships, everything here is available through the API, CLI and MCP.

Screenshot of the TaskCloud console in demo mode: the Sandboxes page of a sample organization lists its sandboxes with their state (running, paused, creating, error), size, template, labels, active time and cost this period, with Pause and Resume buttons.
Console in demo mode: a screenshot of the real console running against its built-in sample data, not a live account.

Built for

Three ways teams use a VM per agent

Evals & RL

Hundreds of identical environments

Prepare an environment once, then fork the running VM, memory included, for every rollout.

  • Up to 50 forks per call, all or nothing
  • Batch jobs at −50% in the EU night window or with priority: "batch"
  • Pay only for the seconds each copy runs

Fork for evals & RL →

Personal coding agents

Claude Code or Codex in the cloud

A persistent box for your own agents that costs nothing while you sleep.

  • Starter: $19/month in usage credit (~630 h of default; unused credit expires)
  • SSH in from anywhere; sessions survive pauses
  • Or Always-on: $19.90/month for a VM that never pauses

Moving from Cube Computer? →

Agent platforms

One VM per end user

Coding agents, "AI developer" products and app builders that give every user their own machine.

  • Bill grows with active work, not with sign-ups
  • Users return to the exact state they left
  • Preview URLs, scoped keys, spend limits and a usage API for re-billing

FAQ

Questions developers ask first

Can I use TaskCloud today?

TaskCloud is in private beta. Create an account to get the Free plan (20 hours of default, 2 concurrent VMs, no card); we enable beta access in batches while we add capacity. Planning a fleet? Tell us about your workload.

What exactly does "pay only while it works" mean?

Compute is billed per second while the VM is running. A paused VM costs $0 in compute. Its snapshot is stored free for 30 days, then $0.03 per GB per month. Disk beyond the included size is $0.05 per GB per month. Plan credit on Starter and Team does not roll over: unused credit expires at the end of the period. Full details on the pricing page.

How is pause different from stopping a VM?

Stopping keeps the disk and throws away memory, so the next start is a fresh boot: services restart, shells are gone, browser tabs are closed. Pause snapshots memory and disk, so resuming continues the same processes. Our target is p95 resume under 800 ms; we will publish measured numbers on the status page.

Is it a container or a real VM?

A real VM. Each sandbox is a Firecracker microVM with its own Linux kernel, running Ubuntu 24.04 with root, systemd and Docker. See security for the isolation model.

How does fork work?

Fork copies a running VM, memory included, into new sandboxes that continue from the same state. One call creates 1–50 copies (more on request), all or nothing. It also works with priority: "batch" for the night discount. See snapshots and fork.

Where does my data live?

On dedicated servers in the EU. We do not offer regions outside the EU yet.

Can I migrate from E2B?

We are building an adapter compatible with the E2B API so most code can switch by changing the SDK import and API key. It is planned for the beta, not shipped yet. Meanwhile see the migration guide.

Do you have GPUs, SOC 2 or open source?

Not yet. There are no GPUs (desktops use software rendering), no SOC 2 report (planned for year two) and the core is not open source today. These are on the roadmap, not in the beta.

Teams & fleets

Running hundreds of agent VMs? Talk to us

During the private beta we onboard eval and RL teams, agent platforms and larger fleets in batches. Tell us about your workload and we will reach out with a slot, capacity planning and a bill estimate based on your usage.

Just trying it out? Create a free account instead: 20 hours of default, 2 concurrent VMs, no card.

No newsletter, no tracking cookies. We only email you about the beta.

Get started

Give your agents a computer that sleeps for free

Free plan: 20 hours of a 4 vCPU / 8 GB VM, no card. Then $0.030 per active hour, billed per second.