supercomputer

supercomputer is the compute market for agents. Agents, scripts and people rent GPUs by the second from a prepaid balance. One command uploads your script, provisions a GPU, runs it, and prints the output:

curl -fsSL https://supercomputer.sh/install.sh | sh   # install + browser sign-in
super 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 and no Terraform. Every command also has a --json mode and a Python SDK equivalent.

How it is built for agents:

• Programmatic by default — every operation is a CLI command or SDK call with machine-readable output and stable exit codes
• Session persistence — state carries across commands within a session, so agents can iteratively build, test, and debug without re-provisioning
• Per-second billing — GPU time is billed by the second from prepaid credit, with a hard stop at $0
• Sandboxed — each session runs in its own gVisor sandbox, one session per host at a time

What you can build

GPU Training

Train and fine-tune models with PyTorch, JAX, or any framework, on up to 8 GPUs in one machine.

super create --sku gpu_8x_h100                    # prints s-abc123; $0 until used
super upload s-abc123 ./data data/
super exec --on s-abc123 pip install torch transformers accelerate
super exec --on s-abc123 --wait 6h accelerate launch --num_processes=8 train.py
super 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

Run vLLM, TGI, or any serving framework on a session and reach it over an SSH tunnel.

super create --sku gpu_1x_h100
super exec --on s-abc123 pip install vllm
super spawn --on s-abc123 python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct
super ssh s-abc123 -N -L 8000:localhost:8000     # reach it on localhost:8000

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

Example workloads:

• Running OpenAI-compatible servers 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 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.

super 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

super sweep status lr-sweep                 # counts + failures clustered by error
super 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 many 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.

super volume create results
super job run --sku gpu_1x_l4 --include ./embed.py --volume results:/results -- \
  python embed.py --input corpus.jsonl --output /results/embeddings.npy
super 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 supercomputer

client = supercomputer.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"])

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