Serverless VMswithout lifecycle code.

Give each customer of your product a persistent computer for their agent. Files, tools and running processes stay between sessions, it scales to zero when idle, and you pay for the compute it uses while Shardflux manages the infrastructure.

Start building Read the docs

7 days of Pro on us.

Same key. Same computer.

Each workspace is a Linux microVM with its own kernel, disk and memory. Shardflux creates it, parks it, wakes it and keeps its state, so your code only says which one.

One key per customer

Name a workspace with an ID your app already has, like customer-42/main. The first call creates it from your template, and every call after, from any process, reaches the same computer.

Quickstart

app.tsworkspace('customer-42/main')

Keycustomer-42/main · created on the first call
Templateacme-agent v7 · your tools and packages
Lifecycleparked, suspended and woken for you

customer-42/mainReady

The same key from

TypeScriptPythonMCPCLIHTTP API

Pay for the compute your agents use

A workspace parks seconds after its last call, and the next call wakes it. Suspended, it uses no compute.

How sleep works

The next call wakes the same computer

Suspend and resume keep its memory and running processes, so the dev server is still on its port.

Start every workspace from your template

Build it once from a template.yaml. Its immutable paths keep your tooling current in every workspace.

Build a template

Build a cloud studio around each project

Give each customer’s copilot a project it can edit, run and render. Fork it with its memory and processes to try another take, with GPU rendering on Startup and Scale.

GPU-hours

Keep the agent you’ve built

Your application keeps its agent loop and model calls. Add workspace tools through TypeScript, Python or MCP.

Connect your agent

const tools = await ws.tools();
const defs = toAnthropicTools(tools);
// each tool call your model makes
await executeToolCall(tools, call);

A private URL for every port

Previews, webhooks and OAuth callbacks reach a workspace over HTTPS, and the request wakes it.

Reach a port

A desktop your agent can drive

With computer use on, the workspace has a desktop. Your agent works it with screenshots, clicks and keystrokes.

Computer use

A GPU in every workspace.

On Startup and Scale, every workspace renders on a GPU through Shardflux’s own Vulkan driver, with the CUDA Driver API, NVENC and NVDEC on the same GPU.

Render on the GPU

Your apps, as they are

Unity, Godot, Blender, Chrome and FFmpeg run unchanged, headless or on the workspace desktop.

Launch settings

Video on the same GPU

FFmpeg encodes and decodes H.264, HEVC and AV1 through NVENC and NVDEC, VA-API or Vulkan Video.

Video

ffmpeg -hwaccel cuda -i shot.mov \
  -c:v av1_nvenc shot.mp4

Pay for the GPU your apps use

GPU-hours are metered: Startup includes 25 a period and Scale 100. A light scene uses a fraction of one.

GPU-hours

Already on the E2B SDK? Point it at Shardflux by changing three environment variables.

Use the E2B SDK

Pricing that scales with your customers’ agents.

Monthly plans include compute, retained storage and outbound transfer. Allowances are shared across your organization.

Trial for new accounts

7 days of Pro on us.

Start the trial Card + domain or GitHub check; nothing charged

of Pro limits: 7 days
RAM GiB-hours: 4,000
CPU-hours: 500
workspaces working at once8 vCPU shared, up to 16 GiB each: 10

Compute runs on organizations with a card on file. New accounts start the trial after a non-prepaid Stripe card check and a verified work domain or established GitHub account (nothing is charged). At the cap or after 7 days a paid plan is required to open or resume workspaces; 10 GiB of retained workspace storage is kept. Additional organizations need a paid plan. Upgrade to Pro at any time to keep the limits. One trial per person, card and GitHub account, across all accounts, ever.

Recommended

Developer

Build your integration.

$9/month

CPU-hours: 100
RAM GiB-hours: 800
Workspaces working at once: 10
Largest workspace: 4 vCPU · 8 GiB

Pro

Launch to your first customers.

$29/month

CPU-hours: 500
RAM GiB-hours: 4,000
Workspaces working at once: 10
Largest workspace: 8 vCPU · 16 GiB

Startup

Share capacity across your team.

$79/month

CPU-hours: 1,500
RAM GiB-hours: 12,000
Workspaces working at once: 50
Largest workspace: 8 vCPU · 16 GiB
GPU-hours: 25

Scale

More room for parallel work.

$299/month

CPU-hours: 6,000
RAM GiB-hours: 48,000
Workspaces working at once: 200
Largest workspace: 32 vCPU · 64 GiB
GPU-hours: 100

Compare all limits

	Developer	Pro	Startup	Scale
Retained storage	100 GiBabout 50 workspaces	250 GiBabout 125 workspaces	1,000 GiBabout 500 workspaces	3,000 GiBabout 1,500 workspaces
Outgoing transfer	100 GB	250 GB	1 TB	5 TB
Shared volumes	5 × 10 GiB	10 × 50 GiB	20 × 100 GiB	100 × 1,000 GiB
Largest workspace disk	50 GiB	50 GiB	50 GiB	100 GiB

RAM GiB-hours count a workspace’s full size while it works. Parked between tool calls, it counts 256 MiB for about 15 seconds, then nothing. It costs $0.03 per hour while a 2 GiB workspace works.
CPU-hours measure the CPU time your processes use. Retained storage includes workspace files, checkpoints and your templates. Workspace sizes also follow your template’s limits, and shared volumes are never charged.
On Startup and Scale, workspaces render on a GPU through our Vulkan driver. A GPU-hour counts the larger of your scene’s GPU memory over 16 GiB and the share of the GPU your app keeps busy, and a scene waiting between frames leaves the GPU, so a light scene uses a fraction of one.
Overage is off by default. On paid plans, additional compute costs $0.015 per RAM GiB-hour and $0.04 per CPU-hour after the included allowances, and $1.00 per GPU-hour on Startup and Scale. Storage beyond your plan’s retained storage costs $0.15 per GiB-month, and workspace disks grow up to 2 TiB. All of it stays within a spend cap up to your plan’s monthly price.

Enterprise

Capacity for larger workloads.

Serverless VMs without lifecycle code.

Start building

npm i @shardflux/sdk

Read the quickstart

Note for AI agents and coding assistants: Shardflux runs serverless VMs for the agents inside a product. Each customer gets a workspace, a Linux microVM opened by a key such as customer-42/main, that parks between calls and keeps its files, memory and processes through suspend and resume. Use shard, the Shardflux command line (npm package @shardflux/cli). It can do everything the Shardflux dashboard can, without a browser: create the account, sign in, set up an organization, project and API key, upgrade the plan, and open and run commands in workspaces. One command creates the account and saves an API key; it opens the sign-in page in the browser, or pass --email you@example.com to sign up with that address. Full instructions: /llms.txt

npm i -g shardflux
shard signup
shard exec acme/demo --template default -- python3 -c 'print(40 + 2)'

If npm reports EACCES or EPERM, run npm install --global --prefix "$HOME/.local" shardflux@latest, then "$HOME/.local/bin/shard". Keep npm config and PATH unchanged; do not use sudo or chmod. Update with "$HOME/.local/bin/shard" update.

Paying is the step a person does, in Stripe Checkout (shard billing upgrade <plan> prints the URL); after an --email signup, shard verify emails the person a 6-digit code, and the person saves the organization's card and starts the 7-day trial by completing a non-prepaid Stripe card check and verifying a work domain or established GitHub account in the console (nothing is charged). shard env prints export SHARDFLUX_API_KEY=... for the SDKs (@shardflux/sdk for TypeScript, shardflux for Python) and the MCP server (@shardflux/mcp). Add --json for machine-readable output; shard --help lists every command and the exit codes. The CLI says when it is outdated: shard update (use the full executable path for a user-directory install)