# SkyPilot

> Run AI jobs on any cloud or Kubernetes and land on the cheapest available GPUs

- Category: Models & Inference / GPU & Compute Clouds
- Language: Python
- Repository: https://github.com/skypilot-org/skypilot
- Website: https://skypilot.readthedocs.io
- Canonical page: https://ai-tldr.dev/tools/skypilot/

## In short

SkyPilot is a system for running, managing, and scaling AI workloads across any compute you have access to. You describe a job once in a small YAML file, and SkyPilot provisions the resources, syncs your code, runs the job, and cleans up idle machines when it finishes. It sits in the GPU & Compute Clouds category of the Models & Inference tools and is open-source, written in Python.

## Overview

SkyPilot is a system for running, managing, and scaling AI workloads across any compute you have access to. You describe a job once in a small YAML file, and SkyPilot provisions the resources, syncs your code, runs the job, and cleans up idle machines when it finishes.

It is built for AI teams who want a single way to launch jobs without hand-managing each cloud, and for infra teams who want one control plane over Kubernetes, Slurm, reserved GPUs, and more than 20 cloud providers. Your existing GPU, TPU, and CPU jobs run with no code changes.

Within compute orchestration, SkyPilot sits above individual schedulers and cloud APIs. It handles GPU/TPU/CPU provisioning with smart failover across providers, queues and auto-recovers jobs, and runs everything inside your own cloud accounts and clusters (BYOC).

## What it does

- One interface to run jobs on Kubernetes, Slurm, reserved GPUs, or 20+ clouds including AWS, GCP, Azure, OCI, Lambda, RunPod, and Nebius
- Flexible provisioning of GPUs, TPUs, and CPUs with automatic failover to available, cheaper infrastructure
- Autostop and binpacking to clean up idle resources and pack workloads onto shared clusters
- Job queueing, multi-node and gang scheduling, and automatic recovery of failed jobs
- Local-style development on Kubernetes: SSH into pods, sync code, or connect your IDE
- BYOC design: clusters launch inside your own cloud accounts, VPCs, and Kubernetes clusters

## Getting started

Install SkyPilot with the cloud and Kubernetes backends you need, then launch your first cluster from a short task YAML.

1. Install SkyPilot

   Install with uv (pip, nightly, and from-source are also supported) and pick the infra extras you plan to use. This example enables Kubernetes and the major clouds.

```bash
uv pip install "skypilot[kubernetes,aws,gcp,azure,oci,nebius,lambda,runpod,fluidstack,paperspace,cudo,ibm,scp,seeweb,shadeform,verda]"
```

2. Define a task

   Write a task YAML that declares the resources you want, a setup step, and the command to run. If you omit infra, SkyPilot picks the cheapest option for you.

```yaml
resources:
  infra: k8s/coreweave
  accelerators: B200:8

workdir: .

setup: |
  uv pip install torch

run: |
  echo "Hello, SkyPilot!"
  nvidia-smi
```

3. Launch and check status

   Provision a cluster and run the task with sky launch, then view your clusters with sky status.

```bash
sky launch -c mycluster hello_sky.yaml
sky status
```

## When to use it

- Running model training or fine-tuning jobs on whichever cloud has the cheapest available GPUs
- Giving an infra team one control plane over multiple Kubernetes and Slurm clusters
- Queueing and auto-recovering many batch jobs across a shared GPU fleet
- Spinning up an interactive dev environment on Kubernetes with code sync and IDE access