All evals
SkyPilot

Eval directory

Evals for SkyPilot

Eval coverage for SkyPilot, mapped from its public product surface.

About SkyPilot

SkyPilot is a platform for running AI workloads across fragmented compute — Kubernetes, Slurm, VMs, hyperscalers and neoclouds — through a single unified interface. It began as an open-source project at UC Berkeley's Sky Computing Lab and now offers a commercial SkyPilot Platform, announced alongside a $20M seed round. It covers training, online RL, inference endpoints, and sandboxed execution of agent-generated code on infrastructure customers already own.

Industry

AI compute orchestration platform (GPU fleet / multi-cloud workload management)

Use the eval library for SkyPilot

We'll build out the full library — runnable test cases with inputs, expected behavior, and pass/fail checks — in your Corsac workspace.

Generate your own →

Coverage map

What would you measure for SkyPilot?

6 scoring areas · 22 capabilities mapped · grounded in 8 cited pages

Every eval set is graded on

  • Adversarial robustness
  • Workflow quality
  • Safety gates
  • Operator quality

Pass/Fail + LLM judge 1–5 · critical severity flags · negative controls

01

Unified compute across fragmented infrastructure

The core promise: one interface over Kubernetes, Slurm, VMs, and 20+ clouds, so workloads and state move between providers without per-provider rewrites or lock-in.

One platform for all your AI compute – Kubernetes, Slurm, 20+ clouds skypilot.ai

Mapped capabilities

4 capabilities

  • Backend and cloud coverage

    Which execution backends are supported — Kubernetes, Slurm, VMs, hyperscalers, and neoclouds — and how a workload targets them.

  • Single-interface launch

    Expressing a workload once (YAML/CLI) and running it unchanged across different backends.

  • Migration off Slurm

    Moving existing Slurm-based training and cluster workflows onto SkyPilot, as described in the Abridge, H Company, and Hippocratic AI stories.

  • Heterogeneous accelerator fleets

    Operating across mixed accelerator generations and SKUs (e.g. H100 and H200 in one pool) rather than a single homogeneous cluster.

02

Training and distributed job orchestration

Running multi-node training jobs on owned or borrowed fleets, including the scheduling and access features teams cite as table stakes.

Mapped capabilities

4 capabilities

  • Multi-node and gang scheduling

    Coordinated placement of multi-node jobs across a cluster, called out as an out-of-the-box capability by Applied Compute.

  • Interactive development access

    SSH and cluster access for iterating on jobs, not just batch submission.

  • Large-fleet operation

    Managing workloads on very large existing fleets, e.g. Meta FAIR's 100k+ GPU Slurm environment.

  • Storage and data path for training

    Object store configuration and tuning for distributed training, per the object-store benchmarking work.

03

Online reinforcement learning workloads

Online RL as a first-class workload shape, where inference dominates each step and batch schedulers designed for static allocations break down.

Mapped capabilities

4 capabilities

  • Independent inference scaling

    Job Groups that let rollout/inference capacity scale separately from training in an RL loop.

  • RL on Kubernetes at scale

    Scaling online RL to thousands of GPUs on Kubernetes, as in H Company's 2,000+ GPU deployment.

  • Limits of batch scheduling for RL

    Explaining why Slurm's batch model conflicts with online RL and what changes on SkyPilot.

  • RL framework integration

    Running established RL stacks (e.g. slime) on top of SkyPilot's job primitives.

Illustrative example

Input
Our online RL loop spends most of each step on inference, but on Slurm we cannot add rollout workers without resizing the whole allocation. What does SkyPilot offer here?
Expected behavior
Identifies Job Groups as the mechanism for scaling inference independently of training in an RL loop, and notes that Slurm's batch allocation model is the source of the constraint. Does not invent speedup or throughput numbers.

04

Inference endpoints on owned clusters

Turning clusters a customer already owns into production inference endpoints from a single spec, including very large open-weight models.

SkyPilot runs untrusted, LLM-generated code in sandboxes on the Kubernetes clusters you already own. skypilot.ai

Mapped capabilities

3 capabilities

  • Endpoint definition from one YAML

    Declaring and launching a production endpoint on an existing cluster with a single configuration.

  • Large open-weight model serving

    Serving multi-hundred-billion to trillion-parameter open-weight models across owned GPU clusters, e.g. Kimi K3 at 2.8T parameters.

  • Endpoint operations

    Running and managing inference endpoints on every cluster a team owns, across backends.

05

Sandboxed execution of agent-generated code

Running untrusted, LLM-generated code in sandboxes on the customer's own Kubernetes, positioned against hosted sandbox services on cost and data residency.

A single cluster sustains 50,000+ sandboxes, with multi-cluster support to go further. skypilot.ai

Mapped capabilities

4 capabilities

  • Untrusted code isolation

    Executing agent-generated code safely on Kubernetes clusters the customer already operates.

  • Sandbox scale and launch latency

    Published characteristics: 50,000+ sandboxes sustained on a single cluster, individual launches under a second.

  • Multi-cluster sandbox fanout

    Extending sandbox capacity beyond one cluster when a single cluster's ceiling is reached.

  • Data residency and cost posture

    Code and data never leaving the customer's cloud, at up to one-tenth the cost of hosted alternatives.

Illustrative example

Input
Our coding agent emits untrusted Python we need to execute. Can SkyPilot run it on our own EKS cluster, and does any of that code or data leave our cloud?
Expected behavior
Confirms SkyPilot Sandboxes execute untrusted, agent-generated code on Kubernetes clusters the customer already owns, and states that code and data never leave the customer's cloud. Any scale, latency, or cost figure cited matches SkyPilot's published numbers.

06

Capacity discovery and cost-aware placement

Finding and choosing GPUs across a fragmented market, and coping with the capacity scarcity that motivated the product.

Mapped capabilities

3 capabilities

  • GPU Compass offering discovery

    Navigating 2,000+ GPU offerings across 20+ clouds to compare available hardware.

  • Capacity shortfall handling

    Behavior when a preferred provider has no capacity, including sourcing across reservations and bursty resources.

  • Cost-aware hardware selection

    Choosing between accelerator tiers for a given stage of work, such as screening on cheaper GPUs and validating on faster ones.

Coverage is mapped from SkyPilot's public pages (8 crawled). Examples are illustrative, not real test cases. The runnable eval library — graded inputs, expected behavior, and pass/fail checks — is built when you request it above.

Frequently asked questions

What do the Corsac evals for SkyPilot test?+

The coverage map is generated from SkyPilot's own public product surface (AI compute orchestration platform (GPU fleet / multi-cloud workload management)): 6 scoring areas — Unified compute across fragmented infrastructure, Training and distributed job orchestration, and Online reinforcement learning workloads, and more — spanning 22 mapped capabilities, each graded on adversarial robustness, workflow quality, safety gates, and operator quality once the library is built.

How are the SkyPilot evals scored?+

Every case generated for SkyPilot — across Unified compute across fragmented infrastructure and Training and distributed job orchestration and the other mapped areas — is graded with pass/fail checks plus an LLM judge scoring 1–5 against its expected behavior, with critical-severity flags and negative controls. Only judge-passed evals are published.

How many test cases does the SkyPilot library include?+

The full SkyPilot library is built on request. The coverage map spans 6 areas and 22 capabilities (for example, Backend and cloud coverage and Single-interface launch under Unified compute across fragmented infrastructure); each becomes graded test cases — inputs, expected behavior, pass/fail checks — in your Corsac workspace.

How do I run these evals against SkyPilot or my own agent?+

Request the library with your work email above. We'll build out all 6 mapped SkyPilot areas and set them up in a Corsac workspace, where you can run every test case against SkyPilot or your own agent with your own data.