fcloud

fcloud is an AI-first GPU cloud — built from the ground up for AI agents and autonomous workflows, not retrofitted from legacy cloud infrastructure.

Traditional cloud GPUs were designed for humans clicking through consoles. fcloud is designed for code that provisions its own compute. One command uploads your script, provisions a GPU, runs it, and prints the output:

pip install fcloud-sdk
fcloud run train.py --sku gpu_1x_l4

An AI agent (or a CI pipeline, or you) can spin up a GPU session, install dependencies, run a training job, and tear it down — all from the terminal, with no YAML, no Terraform, and no waiting. Every command also has a --json mode and a Python SDK equivalent, so GPUs become a function call rather than an infrastructure project.

What makes it AI-first:

• Programmatic by default — every operation is a CLI command or SDK call, so agents and automated pipelines are first-class citizens, not an afterthought
• Sub-second cold starts — memory snapshots mean containers resume instantly, critical for agents that spin up and down frequently
• Session persistence — state carries across commands within a session, so agents can iteratively build, test, and debug without re-provisioning
• Per-second billing — agents that run for 47 seconds pay for 47 seconds, not a full hour or a reserved instance commitment
• Secure sandboxing — agents can execute untrusted code in isolated containers without risking the host, enabling safe autonomous experimentation

What you can build

GPU Training

Train foundation models, large language models, and world models with PyTorch, JAX, or any framework. fcloud handles multi-GPU orchestration so you focus on the model.

fcloud create --sku gpu_8x_h100                    # prints s-abc123; $0 until used
fcloud upload s-abc123 ./data data/
fcloud exec --on s-abc123 pip install torch transformers accelerate
fcloud exec --on s-abc123 --wait 6h accelerate launch --num_processes=8 train.py
fcloud stop s-abc123                               # halt spend; files kept

Common frameworks: PyTorch, JAX, DeepSpeed, FSDP, Hugging Face Transformers, Axolotl, torchtune

Example workloads:

• Fine-tuning Llama 3 and Mistral on custom datasets
• Pre-training GPT-style models with Megatron-LM
• Training vision transformers (ViT, DINOv2) on ImageNet-scale data
• Training diffusion models (Stable Diffusion, Flux) for image generation

GPU Inference

Deploy and serve models with sub-second cold starts. Run vLLM, TGI, or any serving framework on fcloud GPUs.

fcloud create --sku gpu_1x_h100
fcloud exec --on s-abc123 pip install vllm
fcloud spawn --on s-abc123 python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct
fcloud tunnel s-abc123 --port 8000                 # reach the endpoint locally

Common frameworks: vLLM, Text Generation Inference (TGI), TensorRT-LLM, SGLang, Ollama, llama.cpp

Example workloads:

• Hosting OpenAI-compatible API endpoints for Llama, Mistral, Qwen
• Running multi-modal models (LLaVA, Pixtral) for vision+language tasks
• Batch inference over large datasets with vLLM offline mode
• Serving Whisper for real-time speech-to-text

Hyperparameter Sweeps & Batch

Fan one command out over N argument bindings as a durable server-side sweep — submit, disconnect, and let the service queue, retry, and record every task.

fcloud map --name lr-sweep --sku gpu_1x_l4 \
  -- python train.py --lr {lr} --bs {bs} ::: lr=1e-4,3e-4,1e-3 ::: bs=32,64

fcloud sweep status lr-sweep                 # counts + failures clustered by error
fcloud sweep harvest lr-sweep '*.json' ./out # every task's outputs → out/task-<i>/

Example workloads:

• Hyperparameter sweeps (cartesian products, zipped pairs, or one task per stdin line)
• Sharded data generation across hundreds of workers
• Batch inference and evaluation grids

Data Processing

Process large datasets on GPUs — embeddings, feature extraction, ETL pipelines. Run-to-completion jobs write results to a named volume and keep nothing else.

fcloud volume create results
fcloud job run --sku gpu_1x_a10g --include ./embed.py --volume results:/results -- \
  python embed.py --input corpus.jsonl --output /results/embeddings.npy
fcloud volume download results embeddings.npy

Common frameworks: sentence-transformers, RAPIDS cuDF, Dask-CUDA, cuML, NVIDIA NeMo

Example workloads:

• Generating embeddings for millions of documents with sentence-transformers
• GPU-accelerated dataframe processing with RAPIDS cuDF
• Video/image feature extraction at scale with CLIP or DINOv2
• Audio transcription pipelines with Whisper

Prefer Python? Same platform, same primitives

Everything the CLI does is available from the Python SDK:

import fcloud

client = fcloud.Client()
project = client.project("llama-finetune")

with project.session(sku="gpu_8x_h100") as s:
    s.upload("./data", "data/")
    s.run(["pip", "install", "torch", "transformers", "accelerate"])
    s.run(["accelerate", "launch", "--num_processes=8", "train.py"])

Why fcloud

Next steps

• Quickstart — install the CLI and run your first command
• CLI Reference — every command, grouped by task
• Sessions — persistent GPU sessions
• Python SDK — the programmatic interface