fantasti workspace open rl-devDevelopWorkspaces 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") | Field | Value |
|---|---|
| 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
# 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.
- API reference
- MCP server Early access
What's inside.
- IDE VS Code, JupyterLab, terminal In the browser, or connect VS Code or Cursor over SSH.
- Cluster Ray head and GPU workers Workers scale up from zero when your code asks for GPUs.
ray.init() - State Files persist The workspace directory survives stop and start.
/workspace - Spot Workers with a max price Follow the market or set a ceiling per GPU-hour.
max_price: follow - Tracking Managed MLflow Every node has your tracking URI set.
MLFLOW_TRACKING_URI
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.
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.
/workspaceEditor and codeMLflow URI set
- VS Code
- JupyterLab
- Terminal
- SSH
- mode
- on-demand
- nodes
- min 0 · max 2
0 of 2 nodes- mode
- spot · follow
- nodes
- min 0 · max 4
0 of 4 nodes- /workspace
- Volumes and buckets
- Git
Same files in both shapes.
- Stop and start
- kept
- One GPU to cluster
- kept
/workspaceEditor and codeMLflow URI set
- VS Code
- JupyterLab
- Terminal
- SSH
- mode
- on-demand
- nodes
- min 0 · max 2
0 of 2 nodes- mode
- spot · follow
- nodes
- min 0 · max 4
0 of 4 nodes/workspaceVolumes and bucketsGit- Stop and start
- kept
- One GPU to cluster
- kept
- Files
- Scales out to
- Worker groups you can add
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.
/workspace (persists)Ray headMLflow tracking URI
- VS Code
- JupyterLab
- Terminal
- SSH
- mode
- on-demand
- nodes
- min 0 · max 2
1 of 2 nodes- mode
- spot · follow
- nodes
- min 0 · max 4
1 of 4 nodes- /workspace
- Volumes and buckets
- Git
Same files in both shapes.
- Stop and start
- kept
- One GPU to cluster
- kept
/workspace (persists)Ray headMLflow tracking URI
- VS Code
- JupyterLab
- Terminal
- SSH
- mode
- on-demand
- nodes
- min 0 · max 2
1 of 2 nodes- mode
- spot · follow
- nodes
- min 0 · max 4
1 of 4 nodes/workspaceVolumes and bucketsGit- Stop and start
- kept
- One GPU to cluster
- kept
- Files
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
0 lines of Fantasti SDK inside your training loop.
import rayray.init() # connects to this workspace's Ray cluster From notebook to running job.
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.
$ fantasti workspace create rl-dev--gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev--ide cursorrl-dev editor openRay dashboard,GPU metrics and logswhile you debug.
- VS Code
- JupyterLab
- SSH
$ uv run train.pyrunning 1 GPU$ fantasti workspace scale rl-dev--workers B200:8 --min 0 --max 4--spot --max-price follow2 of 4 nodes up- head
- 16 vCPU · on-demand
HGX B200 · 8 GPUs
$ fantasti job submit --from-workspace rl-dev-- uv run train.py --epochs 3job_7c2m… submitted- inherits
- image · packages · files
idle_stop: 45mGPUs releasedfiles keptFiles, packages andvariables carry over.
$ fantasti workspace create rl-dev--gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev--ide cursorrl-dev editor openRay dashboard,GPU metrics and logswhile you debug.
- VS Code
- JupyterLab
- SSH
$ uv run train.pyrunning 1 GPU$ fantasti workspace scale rl-dev--workers B200:8 --min 0 --max 4--spot --max-price follow2 of 4 nodes up- head
- 16 vCPU · on-demand
HGX B200 · 8 GPUs
$ fantasti job submit--from-workspace rl-dev-- uv run train.py --epochs 3job_7c2m… submitted- inherits
- image · packages · files
idle_stop: 45mGPUs releasedfiles keptFiles, packages andvariables carry over.
$ fantasti workspace create rl-dev--gpu H100:1 --idle-stop 45m$ fantasti workspace open rl-dev--ide cursorrl-dev editor openRay dashboard,GPU metrics and logswhile you debug.
- VS Code
- JupyterLab
- SSH
$ uv run train.pyrunning 1 GPU$ fantasti workspace scale rl-dev--workers B200:8 --min 0 --max 4--spot --max-price follow2 of 4 nodes up- head
- 16 vCPU · on-demand
HGX B200 · 8 GPUs
$ fantasti job submit--from-workspace rl-dev-- uv run train.py --epochs 3job_7c2m… submitted- inherits
- image · packages · files
idle_stop: 45mGPUs releasedfiles keptFiles, packages andvariables carry over.
- to
- Open
- One workspace, in order
- Start again from the same files
| Step | You | Fantasti |
|---|---|---|
| 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. |
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.
| 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
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.
| GPU | Lowest 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.
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×
Blocked at start
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.
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 |
Questions and answers.
Do I have to use Ray?
What happens when I stop a workspace?
Can I use my own container image?
Can I connect my local editor?
How is a workspace billed?
What does a spot max price do?
How do I get access?
Your next cluster starts as a notebook.
Workspaces is in early access. Request access and tell us what you are building.