DevelopWorkspaces Early access

From one GPU to a Ray cluster, without leaving your editor.

Workspaces are GPU development environments on Fantasti capacity. Start in VS Code or JupyterLab on a single GPU. When the work outgrows it, add GPU workers and run the same Ray code across them. Your files, packages and bill stay the same.

fx.workspaces.create(gpu="H100:1")
Being built for the first cohort. Join by request.
TAB 01Workspace record Illustrative
Workspace record, illustrative: the fields of one workspace named rl-dev.
FieldValue
name rl-dev
image ghcr.io/acme/train:latest
head 16 vCPU · on-demandVS Code, JupyterLab, terminal, SSH
workers B200:8 × 0–4 · spotmax_price follow
files /workspacepersists across stop and start
idle_stop 45m
state runninghead ready · workers 0 of 4
Interfaces
VS Code · JupyterLab · terminal · SSH
Cluster
Ray head · workers from zero
Capacity
on-demand · spot with max_price
Billing
Compute rates · one statement
§01 It's just Ray Preview API
Preview API · subject to change
# Inside a workspace: plain Ray, nothing Fantasti-specific
import ray
ray.init()  # connects to this workspace's Ray cluster

ds = ray.data.read_parquet("s3://acme-data/prompts/")
ds = ds.map_batches(  # workers scale up from 0
    Embedder, concurrency=8, num_gpus=1, batch_size=256,
)
ds.write_parquet("s3://acme-data/embeddings/")

Workspace events · illustrative

head      ready    16 vCPU · on-demand
workers   0 → 1    B200:8 · spot · map_batches asked for 8 GPUs
workers   1 → 0    released when the work is done
fantasti workspace create rl-dev --gpu H100:1 \
  --image ghcr.io/acme/train:latest --idle-stop 45m
fantasti workspace open rl-dev --ide cursor          # or: vscode | jupyter | ssh

# Scale out: the CPU head keeps your editor and files; B200 workers scale from zero
fantasti workspace scale rl-dev --workers B200:8 --min 0 --max 4 \
  --spot --max-price follow

# Ship the same code as a job (inherits image, env, secrets, files)
fantasti job submit --from-workspace rl-dev -- uv run train.py --epochs 3
{
  "mcpServers": {
    "fantasti": { "type": "http", "url": "https://mcp.fantasti.ai/mcp" }
  }
}

Workspace tools · early access

workspaces_list
workspaces_start
workspaces_stop    asks for confirmation
# workspace.yaml  (fx.workspaces.create(spec="workspace.yaml"))
name: rl-dev
image: ghcr.io/acme/train:latest
head: { cpu: 16, capacity: on_demand }   # editor, Ray head, files
workers:
  - gpu: B200:8
    min: 0
    max: 4
    capacity: { mode: spot, max_price: follow }   # or a USD limit per GPU-hour
env: { WANDB_MODE: offline }
secrets: [HF_TOKEN]
volumes: ["s3://acme-data:/mnt/data:ro"]
idle_stop: 45m
mlflow: default                         # sets MLFLOW_TRACKING_URI on every node

It's just Ray.

Inside a workspace, ray.init() connects to the workspace's own cluster. The code you write on one GPU is the code you scale out. There is no Fantasti SDK inside your training loop.

A single-GPU workspace runs any code. Scaling across nodes uses Ray.

§02 What's inside 5 parts

What's inside.

§03 One GPU to a cluster Illustrative

Develop on one GPU.
Run on many.

Every workspace is a Ray cluster. Small work runs on one GPU. When your code asks for more, Ray adds GPU workers and releases them when the work is done.

In cluster mode the editor, the Ray head and your files sit on an on-demand CPU node, and the GPUs sit on worker groups. A reclaimed spot worker never takes your session with it.

Moving from one GPU to cluster mode restarts the workspace on the new shape. Files, packages and environment variables carry over.

Same workspace, same files, two shapes.

Workspace shape, one GPU. Illustrative.

One GPU mode: a single H100 runs the editor and your code, with VS Code, JupyterLab, a terminal and SSH. Storage is the same: the workspace directory, volumes and buckets, and Git. Worker groups are not created yet: the two groups of cluster mode are drawn as quiet cards with no node up. Add groups of H100, H200, B200 or B300 nodes, on demand or on spot, to scale out. Workers scale up from zero. Connections: Workspace to H100:8; Workspace to B200:8; Workspace to Storage.

  • WorkspaceH100:1 · on-demand
    /workspace

    Editor and codeMLflow URI set

    • VS Code
    • JupyterLab
    • Terminal
    • SSH
  • WorkersH100:8not created
    mode
    on-demand
    nodes
    min 0 · max 2
    0 of 2 nodes
    HGX H100 8-GPU baseboard, line drawing
  • WorkersB200:8not created
    mode
    spot · follow
    nodes
    min 0 · max 4
    0 of 4 nodes
    HGX B200 8-GPU baseboard, line drawing
  • StoragePersists
    • /workspace
    • Volumes and buckets
    • Git

    Same files in both shapes.

    Stop and start
    kept
    One GPU to cluster
    kept
  • WorkspaceH100:1 · on-demand
    /workspace

    Editor and codeMLflow URI set

    • VS Code
    • JupyterLab
    • Terminal
    • SSH
  • WorkersH100:8not created
    mode
    on-demand
    nodes
    min 0 · max 2
    0 of 2 nodes
    HGX H100 8-GPU baseboard, line drawing
  • WorkersB200:8not created
    mode
    spot · follow
    nodes
    min 0 · max 4
    0 of 4 nodes
    HGX B200 8-GPU baseboard, line drawing
  • StoragePersists
    /workspaceVolumes and bucketsGit
    Stop and start
    kept
    One GPU to cluster
    kept
  • Files
  • Scales out to
  • Worker groups you can add
Workspace shape, cluster. Illustrative.

Cluster mode: an on-demand CPU head node runs VS Code, JupyterLab, a terminal, SSH, the Ray head and the persistent workspace directory. Worker group one has H100:8 nodes on demand, scaling from 0 to 2, with 1 running. Worker group two has B200:8 nodes on spot following the market price, scaling from 0 to 4, with 1 running. Storage holds the workspace directory, volumes and buckets, and Git. Connections: Head node to H100:8; Head node to B200:8; Head node to Storage.

  • Head nodeCPU · on-demand
    /workspace (persists)

    Ray headMLflow tracking URI

    • VS Code
    • JupyterLab
    • Terminal
    • SSH
  • WorkersH100:81 running
    mode
    on-demand
    nodes
    min 0 · max 2
    1 of 2 nodes
    HGX H100 8-GPU baseboard, line drawing
  • WorkersB200:81 running
    mode
    spot · follow
    nodes
    min 0 · max 4
    1 of 4 nodes
    HGX B200 8-GPU baseboard, line drawing
  • StoragePersists
    • /workspace
    • Volumes and buckets
    • Git

    Same files in both shapes.

    Stop and start
    kept
    One GPU to cluster
    kept
  • Head nodeCPU · on-demand
    /workspace (persists)

    Ray headMLflow tracking URI

    • VS Code
    • JupyterLab
    • Terminal
    • SSH
  • WorkersH100:81 running
    mode
    on-demand
    nodes
    min 0 · max 2
    1 of 2 nodes
    HGX H100 8-GPU baseboard, line drawing
  • WorkersB200:81 running
    mode
    spot · follow
    nodes
    min 0 · max 4
    1 of 4 nodes
    HGX B200 8-GPU baseboard, line drawing
  • StoragePersists
    /workspaceVolumes and bucketsGit
    Stop and start
    kept
    One GPU to cluster
    kept
  • Files

§04 Capabilities 6 plates

What a workspace gives you.

Six things every workspace has, whether it runs on one GPU or a cluster.

  • 01

    Your tools, on real GPUs.

    Hosted VS Code, JupyterLab and a terminal, or your own editor over SSH.

    • Desktop editorsconnect VS Code or Cursor over SSH
    • Open portsTensorBoard or a demo app as an authenticated link
    • Agentscoding agents drive workspaces through the same API
    fantasti workspace open rl-dev --ide cursor
  • 02

    One GPU to a cluster.

    Add Ray worker groups of H100, H200, B200 or B300 nodes that scale from zero.

    • Worker groupsset GPU type, minimum and maximum per group
    • Scale to zeroidle workers are released
    • One fabrica multi-node group stays on one InfiniBand fabric
    --workers B200:8 --min 0 --max 4
  • 03

    An environment that follows you.

    Pick a container image, then install with pip or uv.

    • Tracked installspackages you add apply to every node
    • Variables and secretsset once, available on every node
    • Jobs inherit ita job you submit gets the same image and packages
    image: ghcr.io/acme/train:latest
  • 04

    Files that stay put.

    The workspace directory persists across stop and start.

    • Volumes and bucketsmount datasets and checkpoints
    • Gitclone over HTTPS or SSH
    • Duplicatecopy a workspace's code, image and settings
    volumes: ["s3://acme-data:/mnt/data:ro"]
  • 05

    From notebook to job.

    Submit the code you are running as a Fantasti job or a batch-inference run.

    • Same environmentimage, packages, variables and files carry over
    • Trackedruns log to managed MLflow
    • Spot-readyjobs run on spot with your max price
    fantasti job submit --from-workspace rl-dev
  • 06

    Costs you control.

    A workspace uses GPUs while it runs. Stopping it releases them.

    • Idle stopstops after a period with no activity
    • Max uptimea hard limit per workspace
    • Team templatespublish a workspace as a starting point for your team
    idle_stop: 45m
EQ Plain Ray See §01

0 lines of Fantasti SDK inside your training loop.

Inside a workspace: plain Ray
EQ 01 Source · Fantasti · Ray sample, §01
import rayray.init()  # connects to this workspace's Ray cluster

The whole sample

§05 Notebook to job 5 steps

From notebook to running job.

One workspace, from notebook to job. Illustrative.

One workspace named rl-dev in five steps. It opens on H100:1 and you iterate there in VS Code, JupyterLab or over SSH. Scaling adds a group of B200:8 spot workers, 0 to 4 nodes and up to 32 GPUs, on a 16 vCPU on-demand head node. A job submitted from the workspace inherits its image, packages and files. Stopping, by hand or after 45m idle, releases the GPUs and keeps the files in /workspace, where the next start picks them up. Connections: Open to Iterate; Iterate to Scale; Scale to Ship: job; Ship to Stop; Stop to /workspace; /workspace to Open: start again.

  • 01OpenH100:1
    $ fantasti workspace create rl-dev --gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev --ide cursorrl-dev editor open
  • 02Iterate1 GPU

    Ray dashboard,GPU metrics and logswhile you debug.

    • VS Code
    • JupyterLab
    • SSH
    $ uv run train.pyrunning 1 GPU
  • 03ScaleB200:8 × 0–4 · spot
    $ fantasti workspace scale rl-dev --workers B200:8 --min 0 --max 4 --spot --max-price follow
    2 of 4 nodes up
    head
    16 vCPU · on-demand
    HGX B200 8-GPU baseboard, line drawingHGX B200 · 8 GPUs
  • 04Shipjob
    $ fantasti job submit --from-workspace rl-dev -- uv run train.py --epochs 3job_7c2m… submitted
    inherits
    image · packages · files
  • 05Stopidle stop
    idle_stop: 45m
    GPUs releasedfiles kept
  • /workspacepersists

    Files, packages andvariables carry over.

  • 01OpenH100:1
    $ fantasti workspace create rl-dev --gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev --ide cursorrl-dev editor open
  • 02Iterate1 GPU

    Ray dashboard,GPU metrics and logswhile you debug.

    • VS Code
    • JupyterLab
    • SSH
    $ uv run train.pyrunning 1 GPU
  • 03ScaleB200:8 × 0–4 · spot
    $ fantasti workspace scale rl-dev --workers B200:8 --min 0 --max 4 --spot --max-price follow
    2 of 4 nodes up
    head
    16 vCPU · on-demand
    HGX B200 8-GPU baseboard, line drawingHGX B200 · 8 GPUs
  • 04Shipjob
    $ fantasti job submit --from-workspace rl-dev -- uv run train.py --epochs 3job_7c2m… submitted
    inherits
    image · packages · files
  • 05Stopidle stop
    idle_stop: 45m
    GPUs releasedfiles kept
  • /workspacepersists

    Files, packages andvariables carry over.

  • 01OpenH100:1
    $ fantasti workspace create rl-dev --gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev --ide cursorrl-dev editor open
  • 02Iterate1 GPU

    Ray dashboard,GPU metrics and logswhile you debug.

    • VS Code
    • JupyterLab
    • SSH
    $ uv run train.pyrunning 1 GPU
  • 03ScaleB200:8 × 0–4 · spot
    $ fantasti workspace scale rl-dev --workers B200:8 --min 0 --max 4 --spot --max-price follow
    2 of 4 nodes up
    head
    16 vCPU · on-demand
    HGX B200 8-GPU baseboard, line drawingHGX B200 · 8 GPUs
  • 04Shipjob
    $ fantasti job submit --from-workspace rl-dev -- uv run train.py --epochs 3job_7c2m… submitted
    inherits
    image · packages · files
  • 05Stopidle stop
    idle_stop: 45m
    GPUs releasedfiles kept
  • /workspacepersists

    Files, packages andvariables carry over.

    to
    Open
  • One workspace, in order
  • Start again from the same files
TAB 02From notebook to running job Source · Fantasti
From notebook to running job: what you do and what Fantasti does at each of five steps.
StepYouFantasti
01Open Pick an image, a GPU and an idle-stop window. Places the workspace on available capacity and opens your editor.
02Iterate Run and debug on one GPU. Shows the Ray dashboard, GPU metrics and logs.
03Scale Add worker groups, spot or on-demand. Restarts the workspace on a CPU head with GPU workers. Files carry over.
04Ship Submit a job or a batch-inference run, or deploy it as a flow. Planned Runs it with the same image, packages and files, and logs it to MLflow.
05Stop Stop the workspace, or let idle stop do it. Releases the GPUs and keeps your files.
§06 GPUs Reviewed 2026-10-10

Open a workspace on the GPU you'll train on.

Single-GPU workspaces run on H100, H200, B200, B300, RTX PRO 6000 or L40S. Worker groups can use any of them; groups that need InfiniBand use 8-GPU nodes. GB200 NVL72 and GB300 NVL72 are reserved rack-scale capacity, not workspace shapes.

TAB 03GPUs for workspaces · preview list prices Source · Fantasti price list Reviewed 2026-10-10
GPUs for workspaces · preview list prices. USD per GPU-hour, preview list price, reviewed 2026-10-10.
GPU Memory Status On-demand
B300  HGX 8-GPU 270 GB HBM3E Private Preview $10.45 /GPU·hr
B200  HGX 8-GPU 180 GB HBM3E Private Preview $9.35 /GPU·hr
H200 SXM  HGX 8-GPU 141 GB HBM3E Private Preview $5.94 /GPU·hr
H100 SXM5  HGX 8-GPU 80 GB HBM3 Private Preview $5.40 /GPU·hr
RTX PRO 6000  PCIe · Server Edition 96 GB GDDR7 Private Preview $2.16 /GPU·hr
L40S  PCIe 48 GB GDDR6 Private Preview $1.86 /GPU·hr

USD per GPU-hour · preview list price · applies when your account opens · reviewed 2026-10-10

Specifications are NVIDIA reference figures.

Head node
$0.0396per vCPU-hour
In cluster mode the editor and the Ray head run on an on-demand CPU node. Includes 4 GiB of memory per vCPU. CPU Instances
Spot workers
From $0.87per GPU-hour
The spot price always stays below the on-demand rate for the same GPU. Spot floor by GPU
Meter
Per second
Metered by the second, billed hourly. A workspace uses GPUs while it runs; stopping it releases them. Pricing
Sheet
01
Title
Workspaces · workflow and GPU list
Unit
USD per GPU-hour
Reviewed
2026-10-10
§07 Spot workers Illustrative series

Spot workers, with a price you set.

Run worker groups on spot capacity and choose how you pay: follow the market, or set a maximum per GPU-hour. While workers run, you pay the spot price, which is at or below your max.

If the spot price rises above your max, those workers stop. The head node, your editor and your files keep running, and Ray can retry lost tasks on the workers that remain. Workers come back when capacity at your price returns.

The head node is always on-demand.

Spot floor · USD per GPU-hour · reviewed 2026-10-10
GPULowest spot price
B300HGX 8-GPU From $1.09
B200HGX 8-GPU From $1.09
H200 SXMHGX 8-GPU From $0.87
H100 SXM5HGX 8-GPU From $0.87
RTX PRO 6000PCIe · Server Edition From $0.87

"From" is the lowest spot price for that GPU. The spot price moves with supply and demand.

PLT 01Spot price and a max price over 72 hours Illustrative series · not Fantasti market data

Drag the max price line, click the plot, or use the arrow keys.

Worker group
rl-dev · spot
Max price
$2.40 /GPU·hr
Ran
51 h 15 m of 72 h
Stopped
4×
Resumed
4×

Illustrative series, not Fantasti market data. A step line shows a spot price for one GPU type over 72 hours in 15-minute steps, between $1.91 and $2.72 per GPU-hour. With the max price at $2.40, the nodes run 51 h 15 m of 72 hours, stop 4 times when the price rises above the max, and resume 4 times when it falls back. You pay the spot price for each interval, not the max.

§08 Workspaces or Sandboxes 2 products

Workspaces or Sandboxes?

TAB 04Workspaces or Sandboxes Source · Fantasti
Workspaces or Sandboxes
Question Workspaces Early access Sandboxes Early access
Driven by People, and coding agents working with them Agents and test harnesses, through the API
Lifetime Hours to weeks; stop and start Seconds to hours; ends at its time-to-live
State Files persist across stop and start Disposable; copy results out before it ends
Scale One GPU to a Ray cluster Many small environments in parallel
Isolation Your isolated cluster Per-sandbox isolation inside your own node pool
Typical use Research, debugging, training runs RL environments, evals, GPU CI, untrusted code
§09 Q&A 7 questions

Questions and answers.

Do I have to use Ray?

No. A single-GPU workspace runs any code. Scaling across nodes uses Ray.

What happens when I stop a workspace?

The GPUs are released. Files in the workspace directory and attached volumes stay.

Can I use my own container image?

Yes, from a public or private registry.

Can I connect my local editor?

Yes. VS Code and Cursor connect over SSH.

How is a workspace billed?

By the GPU and CPU time it runs, at Compute rates, on your Fantasti statement.

What does a spot max price do?

Your spot workers run while the spot price is at or below your max. If it rises above, those workers stop and your head node keeps running.

How do I get access?

Workspaces is in early access. Access opens in cohorts. Companies can request a place in the first, and places are limited. Request access and tell us what you are building.
§10 Request Early access