Platform

Write a function.
Get a URL.

The platform our own products run on is open to you. Start with a few lines of TypeScript and one command; add a database, a container, or an agent when you need one.

Read the QuickstartOpen the Console
https://my-app.clusterbase.dev

Hello from Clusterbase!

index.ts
export function handler(request: Request): Response {
  return new Response("Hello from Clusterbase!");
}

Build APIs

A handler takes a standard Request and returns a Response. Route with the URL APIs you already know, call anything with fetch, and return JSON in one line.

Functions docs
index.ts
export async function handler(request: Request): Promise<Response> {
  const url = new URL(request.url);

  if (url.pathname === "/api/hello" && request.method === "GET") {
    return Response.json({ message: "Hello!" });
  }

  if (url.pathname === "/api/time") {
    return Response.json({ time: new Date().toISOString() });
  }

  return Response.json({ error: "Not found" }, { status: 404 });
}

Add Postgres in one command

ccp db create gives you a managed Postgres database on its own machine and hands its credentials to your function. Query it over HTTP, or connect a normal Postgres client.

Databases docs
index.ts
export async function handler(request: Request): Promise<Response> {
  const res = await fetch(`https://${process.env.DATABASE_HTTP_URL}/query`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.DATABASE_HTTP_TOKEN}`,
    },
    body: JSON.stringify({
      sql: "SELECT id, email FROM users WHERE id = $1",
      params: [42],
    }),
  });

  const { rows } = await res.json();
  return Response.json(rows);
}

Run any container

Point at an image, or upload a Linux binary with no Dockerfile at all. You get a full machine, a port, and a public URL.

Compute docs
Terminal
$ ccp compute deploy --name hello --image nginxdemos/hello --port 80

 ✓ Service deployed
   name      hello
   image     nginxdemos/hello
   status    running
   URL       https://hello.clusterbase.dev

Create an agent from a YAML file

Describe the agent in a manifest — its model, instructions, and tools — commit it, and apply it with ccp. The file stays the source of truth: edit it and apply again to ship a new version.

Agents docs
agent.yaml
apiVersion: agents.clusterbase.ai/v1
kind: Agent
metadata:
  name: release-notes
spec:
  name: Release Notes
  model: claude-sonnet-5
  system: |
    Write concise release notes.
  tools:
    - web_search
  reasoning_effort: low
Terminal
$ ccp apply -f agent.yaml

Deploy an MCP server

An MCP server is just a service. Build it in any language, ship the binary with ccp compute deploy, and name its URL in an agent manifest. This one gives our News agent a single publish_story tool.

Vaults and MCP docs
cluster.toml
name = "news-api"
mode = "binary"

[binary]
path = "../target/x86_64-unknown-linux-musl/release/news-api"
runtime = "alpine"

[service]
internal_port = 8080
always_on = true

[health]
path = "/ready"
agent.yaml
apiVersion: agents.clusterbase.ai/v1
kind: Agent
metadata:
  name: news-agent
spec:
  name: News Agent
  model: gpt-5.6-luna
  mcp_servers:
    - name: news
      url: https://news-api.clusterbase.dev/mcp
      allowed_tools:
        - publish_story

Put an agent on a schedule

Define an agent once, then give it a cron expression and a kickoff message. Every run gets its own machine and leaves a full transcript.

Managed Agents docs
Terminal
curl https://agents.clusterbase.dev/v1/schedules \
  -H "Authorization: Bearer $CLUSTER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "agent": "agt_3f9c2a",
    "cron": "0 9 * * 1-5",
    "timezone": "America/New_York",
    "kickoff": [{ "type": "text", "text": "Publish the engineering digest." }]
  }'

Sandboxes

Computers for AI. One for every agent.

An agent that can only talk is a chatbot. Give it a computer and it can write the code, run it, open the browser, and check its own work. A Sandbox is that computer: a full Linux machine that starts for the job and is gone when the job is.

Launch a SandboxOpen the Console

One agent, one machine

Run one or run a thousand. Every agent works on its own computer, so a long job, a crash, or a bad idea stays on the machine it happened on.

Testing the checkout flow

Refactoring billing

Reconciling q3.xlsx

Running a backtest

Isolated from everything else

Each Sandbox is its own microVM with its own kernel. Untrusted code runs inside it and stays inside it. The ports you declare stay private, reachable only with a scoped token that expires.

Access to cdpExpires in 5 min

A private address, a scoped token, one declared service. The machine’s own address is never published.

ccp sandbox connect sbx_… cdp --ttl 5m

Built from a recipe

Describe the machine in a YAML file: a base, packages, a setup step. ccp apply turns it into an immutable build, and every launch starts from exactly that.

sandbox.yaml
apiVersion: sandboxes.clusterbase.ai/v1
kind: SandboxTemplate
metadata:
  name: python-tools
spec:
  base: debian
  resources:
    vcpu: 2
    memory_mb: 1024
  packages:
    apt: [jq, python3, python3-venv]

Around as long as the work

Give a Sandbox a lifetime from a minute to a day, or keep it. An idle desktop pauses to free its memory and picks up exactly where it stopped.

  • python-toolsRunning · 11 minutes left
  • desktopPaused while idle · resumes on connect
  • headless-chromeRunning · kept, no expiry

Priced for running a lot of them

One flat hourly price per machine size, billed by the second after a 30-minute minimum, and only while the Sandbox is running. Paused machines cost nothing.

$0.060/ hour

  • Cluster$0.060
  • E2B$0.1171.9x the Cluster price
  • Daytona$0.1171.9x the Cluster price
  • Cloudflare$0.1532.6x the Cluster price
  • Modal$0.1662.8x the Cluster price
  • Vercel Sandboxwith 4 GB$0.3415.7x the Cluster price

Other prices are each vendor’s published per-vCPU and per-GB rates applied to the same machine size, September 2026, for sessions of 30 minutes or more; the others bill shorter runs by the second. Vercel only sells 2 GB per vCPU and bills active CPU, shown here at full use.

Storage

Files served from the edge CDN.

Domains

Custom domains with automatic TLS.

Static sites

Sites and SPAs from a public directory.

from request to running code
<1 ms
from request to running code
every workload, its own machine
isolated
every workload, its own machine
code, machines, agents
1 API
code, machines, agents