AI Fabric · Serverless GPUs for Python Opening gradually

You probably don't need an H100 to train FLUX on your own images.

LoRA on FLUX.1-devpeak 10.8 GiB€0.40/h interruptible
Gemma 4 26B in 4-bit2-way tensor parallel€0.80/h interruptible
Moshi, full-duplex speech~15 GB VRAM€0.40/h interruptible
one gVisor sandbox per task.map() over the tasks€0.05/h per vCPU
LTX-Video in bf16704×480, 25 frames€0.40/h interruptible
Whisper Large v3 Turbo.map() over a volume€0.20/h interruptible
Mistral 7B, LoRAcheckpoints to a volume€0.40/h interruptible

Set the GPU type and count in Python with bladekit. Pay by the minute while your container runs.

€5 in free credits for every new customer.

$ pip install bladekit

train_flux_lora.py

import bladekit
 
app = bladekit.app("flux-lora-a4500")
image = bladekit.Image.from_catalog("fabric/torch").pip_install(
    "diffusers>=0.31.0", "transformers", "peft",
    "bitsandbytes>=0.45.0")
 
@app.function(
    gpu="RTX-A4500",  # 20 GB card, ~19.6 GiB usable
    image=image, timeout=7200, memory=32768,
    volumes={"/data": data_vol, "/output": out_vol},
    secrets=[bladekit.Secret.from_name("hf-token")],  # gated repo
)
def train_flux_lora(base_model="black-forest-labs/FLUX.1-dev",
                    resolution=512, lora_rank=16):
    # NF4 transformer, 8-bit optimiser, text encoders cached then
    # freed: our run peaked at 10.8 GiB with resolution=1024.
    ...

import os, subprocess, sys, bladekit
 
app = bladekit.app("gemma-4-26b", image="fabric/vllm")
 
@app.web_server(startup_timeout=900, scale_down_idle_seconds=900)
@app.function(gpu="RTX-A4500:2", memory=40960)
@app.concurrent(max_inputs=32)
def serve():
    subprocess.Popen([
        sys.executable, "-m", "vllm.entrypoints.openai.api_server",
        "--model", "cyankiwi/gemma-4-26B-A4B-it-qat-AWQ-INT4",
        "--tensor-parallel-size", "2",  # 4-bit: 17 GB over 2 cards
        "--max-model-len", "262144",    # the full 256k window
        "--max-num-seqs", "16", "--dtype", "float16",
        "--port", os.environ["FABRIC_SERVER_PORT"],
    ])

import os, subprocess, bladekit
 
app = bladekit.app("moshi-voice-chat")
image = (bladekit.Image.debian_slim(python_version="3.12")
         .apt_install("ffmpeg")
         .pip_install("moshi==0.2.4", "torch", "sphn",
                      "huggingface_hub"))
 
# Full-duplex speech: it listens and talks at the same time.
# A ~7B transformer and the Mimi codec, about 15 GB of VRAM.
@app.web_server(startup_timeout=900, min_replicas=1, max_replicas=1)
@app.function(gpu="RTX-A4500", image=image,
              secrets=[bladekit.Secret.from_name("hf-token")])
def serve():
    port = os.environ["FABRIC_SERVER_PORT"]
    subprocess.Popen([
        "python", "-m", "moshi.server", "--host", "0.0.0.0",
        "--port", port, "--hf-repo", "kyutai/moshiko-pytorch-bf16",
    ])

import bladekit
 
app = bladekit.app("coding-agents")
agent_image = (bladekit.Image.debian_slim(python_version="3.12")
               .apt_install("git", "nodejs", "npm"))
 
@app.function(timeout=300)
def run_coding_agent(task: dict) -> dict:
    """One coding agent, in its own gVisor sandbox."""
    with bladekit.Sandbox.create(image=agent_image) as sb:
        sb.exec("git", "clone", task["repo"], "/work/repo").wait()
        sb.write_file("/work/task.txt", task["prompt"].encode())
        proc = sb.exec("your-agent", "/work/task.txt")
        proc.wait()
        return {"id": task["id"], "out": proc.stdout.read().decode()}
 
@app.local_entrypoint()
def main():
    tasks = [{"id": i, "prompt": f"Fix issue #{i}", "repo": REPO}
             for i in range(200)]
    results = list(run_coding_agent.map(tasks, return_exceptions=True))

import io, bladekit
 
app = bladekit.app("ltx-video")
hf_cache = bladekit.Volume.from_name("hf-cache", create_if_missing=True)
image = bladekit.Image.from_catalog("fabric/torch").pip_install(
    "diffusers>=0.31.0", "transformers", "accelerate",
    "imageio[ffmpeg]", "sentencepiece").env({"HF_HOME": "/hf-cache"})
 
@app.function(gpu="RTX-A4500", image=image, timeout=1800,
              volumes={"/hf-cache": hf_cache})
def generate_video(prompt: str, num_frames: int = 25) -> bytes:
    import torch, imageio, numpy as np
    from diffusers import LTXPipeline
    pipe = LTXPipeline.from_pretrained(
        "Lightricks/LTX-Video", torch_dtype=torch.bfloat16).to("cuda")
    frames = pipe(prompt=prompt, num_frames=num_frames,
                  width=704, height=480).frames[0]
    buf = io.BytesIO()
    imageio.mimsave(buf, [np.array(f) for f in frames],
                    format="mp4", fps=24)
    return buf.getvalue()

import bladekit
 
image = bladekit.Image.from_catalog("fabric/torch").pip_install(
    "faster-whisper")
app = bladekit.app("transcribe", image=image)
calls = bladekit.Volume.from_name("support-calls")
 
@app.function(gpu="RTX-2000-ADA-GENERATION",
              volumes={"/calls": calls}, retries=3)
def transcribe(path: str) -> str:
    from faster_whisper import WhisperModel
    model = WhisperModel("large-v3-turbo", device="cuda")
    segments, _ = model.transcribe(path)
    return " ".join(s.text for s in segments)
 
@app.local_entrypoint()
def main():
    files = [f"/calls/{n:05}.wav" for n in range(10_000)]
    for text in transcribe.map(files, order="arrival"):
        print(text[:72])

import bladekit
 
app = bladekit.app("interruptible-finetune")
ckpts = bladekit.Volume.from_name("interruptible-ckpts", create_if_missing=True)
 
@app.function(
    gpu="RTX-A4500",
    gpu_class="interruptible",  # cheap, the default
    image=image, timeout=14400, volumes={"/ckpts": ckpts},
    retries=10, max_interruptions=10,  # re-queued after a preemption
)
def train(model_name="mistralai/Mistral-7B-v0.1"):
    model = AutoModelForCausalLM.from_pretrained(
        model_name, torch_dtype=torch.bfloat16)
    model = get_peft_model(model, LoraConfig(
        r=8, target_modules=["q_proj", "v_proj"]))
    ...  # checkpoints to /ckpts every 50 steps, resumes from the last
 
@app.on_preempt
def save_on_preempt(): ...

From our FLUX.1-dev LoRA tutorial.

blade run job.py
.remote() calls run on a GPU and stream logs to your terminal.
blade serve app.py
Reloads your code on the GPU when you save.
blade deploy app.py
Deploys the file's endpoints and crons as a new version. blade app rollback restores an older version.

What runs on it.

Train & fine-tune

Train on interruptible cards.

Use Unsloth, TRL, PEFT, diffusers or veRL.

Resume after a reclaim
Save checkpoints to a volume. Use @app.on_preempt to save when an interruptible card is reclaimed. retries re-queues the run.
Up to eight cards
gpu="RTX-A4500:8" gives one container eight GPUs on the same machine.

@app.function(gpu="RTX-A4500:8", gpu_class="interruptible", retries=10)step 0

Illustration

Inference

Serve over HTTPS.

Run vLLM, SGLang, FastAPI or your own server behind an HTTPS URL.

Scaled on the queue
Autoscale(vllm_target_waiting=4) scales on vLLM's queue, up to max_replicas. scale_down_idle_seconds sets how long an idle replica stays up.
Works with the OpenAI SDK
Point the OpenAI client at your vLLM or SGLang URL. Streaming and WebSockets work.
Non-interruptible minimum
min_replicas=1, reserved_replicas=1 keeps one replica on non-interruptible capacity. Extra replicas run interruptible.

max_replicas=3, autoscale=Autoscale(vllm_target_waiting=4)0 replicas

Illustration

Sandboxes

Run the code your agent writes.

Sandbox.create() starts a gVisor container.

Isolated by default
gVisor sits between the code and the host. block_network=True cuts external network access.
Sandbox API
exec runs code; write_file and read_file handle files. Expose a port with tunnel(port).
CPU or GPU
€0.05 per vCPU-hour without a GPU. Add gpu="RTX-A4500" when the task needs one.

Sandbox.create(image="fabric/base", block_network=True)0 active

Illustration

Batch & jobs

Batches run without your laptop.

.map() spreads up to a million inputs over GPU containers.

Track batch progress
spawn_map() hands back a handle after the upload. Check progress with blade map status from any machine.
Cron in the same file
Add schedule=bladekit.Cron("0 3 * * *") and deploy. It runs every night (UTC), and blade cron trigger runs it now.
Async jobs with webhooks
.spawn(webhook=…) on a deployed function calls your URL, signed, when the result is ready.

handle = transcribe.spawn_map(files)0 / 10,000

Illustration

Your GPU is a
keyword argument.

Four RTX A4500s give you 80 GB of GPU memory, as much as an H100, for €1.60 an hour. Our Models API runs on the same cards.

app.py

@app.function(
    gpu="RTX-A4500:4",
    gpu_class="interruptible",
)
def job(): ...

GPU memory: 80 GB
Price: €1.60/h; €0.0267 per minute
Weights that fit: ≈32B parameters in 16-bit; ≈128B in 4-bit

As much GPU memory as one H100, split over four cards on one machine.

Weights only; 20% of memory left for the KV cache.

Billed by
the minute.

Billed from container start to stop, including model loading and the five idle minutes before scale-down. Image pulls aren't billed. The idle timeout is configurable.

Replica billing

RTX A4500 · interruptible · €0.40 per hour · €0.0067 per minute

Select a phase for billing details.

What one replica costs, phase by phase (example)
Phase	Duration	Billed
Queued	3 s	—
Pulling image	41 s	—
Loading model	52 s	€0.0058
Serving	14 min 8 s	€0.0942
Idle	5 min	€0.0333
Stopped	until the next request	€0
Total	20 min billed	€0.1333

Illustration

Prices

NVIDIA RTX A4500 20 GB
€0.40per hour
interruptible · €0.70 non-interruptible
NVIDIA RTX 2000 Ada 16 GB
€0.20per hour
interruptible · €0.50 non-interruptible
CPU sandboxes and jobs
€0.05per vCPU, per hour
billed on requested vCPUs

Beta prices, excluding VAT, as of 22 October 2026. GPU prices include CPU and RAM. Interruptible is the default and can be reclaimed.

Included in the SDK.

Cached image builds
We build with BuildKit and cache the layers. Your code is uploaded separately, so editing it doesn't trigger a rebuild.
Weights on a volume
Download a model once into a Volume. New containers read it from disk.
Every deploy is a version
blade deploy numbers each release. blade app rollback brings an older one back.

Secrets from your environment
S3 buckets as directories
Live logs that resume
Estimated cost of each run
Queues and dicts between functions

FAQ

When do I need an H100?

For speed or large-scale training. We don't offer H100s today.

I'm coming from Modal. What changes?

Apps, functions, classes, images, volumes, .remote() and .map() mostly map directly. Check the GPU names, fabric/ images and endpoint auth. .spawn() queues calls on a single container; use .map() for parallel work.

Do I need a Dockerfile?

No. Start from fabric/torch, fabric/vllm or fabric/sglang and add packages in Python. Your own Dockerfile or registry image works too.

Which Python versions work?

The SDK requires Python 3.10 or later. With blade run, local Python must match the image version (3.12 by default, 3.13 available). blade deploy has no version-matching requirement.

Where does it run?

In France. Shadow operates the GPUs. Images and volumes are stored on OVHcloud. More in how we handle data.

How do I get access?

Install the SDK from PyPI. To run on the GPUs, request access and tell us what you want to run.

Deployment guides by model

You probably don't need an H100a GB300an H200a B200a GB200a B300an H100 NVL to train FLUX on your own images.to serve an LLM with a 256k context.to run a real-time voice agent.to run coding agents in parallel.to generate video from a prompt.to transcribe 10,000 calls.to fine-tune a 7B on your data.

What runs on it.

Train on interruptible cards.

Resume after a reclaim

Up to eight cards

Serve over HTTPS.

Scaled on the queue

Works with the OpenAI SDK

Non-interruptible minimum

Run the code your agent writes.

Isolated by default

Sandbox API

CPU or GPU

Batches run without your laptop.

Track batch progress

Cron in the same file

Async jobs with webhooks

Your GPU is a keyword argument.

Billed by the minute.

Prices

Included in the SDK.

Cached image builds

Weights on a volume

Every deploy is a version

FAQ

You probably don't need an H100 to train FLUX on your own images.

Your GPU is a
keyword argument.

Billed by
the minute.