Skip to main content
skill CX Codex

runpod · runpod — Claude Code skill: routing provisioning workflows

Skill for Claude Code and Codex that routes Runpod infrastructure tasks. Directs multi-step provisioning to the right tool lane or verified end-to-end recipe.

Apache-2.0 14,600 installs ★ 50 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add runpod/runpod-plugins-official --skill runpod -a claude-code
Open on GitHub

What runpod does

The skill routes Runpod tasks to the appropriate tool lane or end-to-end reference playbook. It executes no infrastructure modifications on its own. Instead, it checks an index of two dozen verified golden paths and points the assistant toward dedicated skills like runpod-mcp, runpodctl, runpod-flash, or runpod-templates.

Routing separates tasks by control interface. Structured agent tool calls route through runpod-mcp, terminal commands and CI pipelines go to runpodctl, and Python application code targets runpod-flash. Storage operations across network volumes route to runpod-companion-clis.

CLI operations require a RUNPOD_API_KEY environment variable or an interactive session through rp login. Using runpodctl requires updating past version 2.12.0, as earlier releases accepted termination flags without backend enforcement.

What it helps with

  • pick the right Runpod skill or CLI before provisioning resources
  • locate verified end-to-end recipes for multi-resource setups
  • route tasks between MCP tool calls, runpodctl, and Python SDK workflows
  • verify control-plane access prior to spinning up billable compute

Example prompts for the agent

  • Find a golden path to deploy a ComfyUI pod with network storage on Runpod
  • Which tool should I use to manage Runpod serverless endpoints in CI?
  • Check prerequisites before setting up a Runpod network volume

How to install runpod

1Skills CLI (Vercel)

npx skills add runpod/runpod-plugins-official --skill runpod -a claude-code

2Manually: put the files in place

~/.claude/skills/runpod/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/runpod/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about runpod

How to install runpod in Claude Code?

Run npx skills add runpod/runpod-plugins-official --skill runpod -a claude-code.

What does the runpod skill do?

It functions as an entrypoint router that directs infrastructure tasks to the correct Runpod tool lane or verified deployment path.

What is required to run the runpod skill?

You need runpodctl version 2.12.0 or newer or an active MCP server connection, along with a RUNPOD_API_KEY for CLI operations.

Source text

SKILL.md · Apache-2.0
---
name: runpod
description: >-
  Start here when the Runpod lane is unclear: picks the skill for a task
  (runpod-mcp and the journey playbooks it routes to, such as runpod-serverless-deploy,
  runpod-pod-deploy, runpod-pod-doctor and runpod-cost-audit; runpodctl, runpod-flash, runpod-companion-clis,
  runpod-usage, runpod-templates, runpod-build-template, runpod-migrate) and
  indexes two dozen end-to-end worked examples (golden paths). Use it before any
  multi-step or provisioning task, even when the lane is clear, to check for a
  matching golden path; for the Runpod MCP tools, runpod-mcp owns
  the answer contract, connection and tool rules.
metadata:
  author: runpod
  version: "2.1.0" # x-release-please-version
  concepts: [runpod-platform, pod, serverless-endpoint, template, network-volume, hub-repo]
license: Apache-2.0
---

# Runpod (router)

The entrypoint for the Runpod skills. This skill does no work itself: it picks the lane
and points at the [golden path](#worked-examples-golden-paths) or journey skill that
carries the procedure. For a multi-step or provisioning task, check the worked examples
first and let the matching one pick the lane; otherwise read the matching skill's
`SKILL.md` next.

**Who owns what** (one home per rule; the others link to it):

| Topic | Owner |
| --- | --- |
| Lane choice, MCP-vs-runpodctl matrix, golden-path index | this skill |
| MCP answer contract, MCP connection and auth, MCP tool-use rules, journey routing | [runpod-mcp](../runpod-mcp/SKILL.md) (load it before the first Runpod MCP tool call) |
| Credentials for every lane, tool updates, control-plane check | [`getting-started.md`](../runpod-usage/reference/getting-started.md) |
| Deployment loop (prefer prebuilt, plan, verify, teardown) | [`development-loop.md`](../runpod-usage/reference/development-loop.md) |
| CUDA floor, Secure vs Community Cloud | [`gpu-selection.md`](../runpod-usage/reference/gpu-selection.md) (steps 3 and 5) |

## The lanes

| Lane | Use it for |
| --- | --- |
| **runpod-mcp** | Manage infra (pods, endpoints, jobs, templates, volumes, registries, catalog, billing) via **structured tool calls** — when the Runpod MCP tools are connected in this session. It routes on to the journey skill for the task. |
| **runpodctl** | Manage the same infra from a **terminal/CI/script**, including Hub browse/deploy, file transfer (`send`/`receive`, `network-volume upload`/`download`), SSH keys, `doctor` setup, and model cache. |
| **runpod-flash** | **Write Python** that runs on Runpod serverless with the Runpod SDK — `runpod.App` with `@app.queue`/`@app.api`/`@app.task`, `rp flash dev`, `rp flash deploy`; also maintains or migrates legacy `runpod-flash` projects. Code-first, not infra management. |
| **runpod-companion-clis** | **Prerequisite artifacts**: download a model (`hf`), build/push an image (`docker`), repos/releases (`gh`), other S3 tools against a network volume (`aws`; runpodctl v3.1.0+ `network-volume upload`/`download` is the default for moving files). |
| **runpod-usage** | **Understand** how Runpod works before acting — pods vs serverless, building a container, storage, GPU selection, gotchas. Knowledge only. |
| **runpod-templates** | **Official prebuilt pod templates** (ComfyUI, PyTorch, …): is there one for this workload, and what does its image ship — ports, paths, autostart, readiness, what's missing on first boot. Reference + routing hub; deploy via runpod-mcp/runpodctl. |
| **runpod-build-template** | **Create or improve a template project** from a request, local code, or GitHub: documented Dockerfile, app-specific files, and Pod/queue/load-balanced deployment handoff. |
| **runpod-migrate** | **Move existing code** off the GraphQL API or REST v1 onto REST v2 — inventory which parts use which version, rewrite call sites, flag breaking changes. Edits the user's code; does not manage infra. |

## These skills are a snapshot; the tools are the source of truth

Every lane wraps something that ships on its own release train and moves faster than this
repo. So route with these skills, but **take capability and syntax from the tool in front
of you**:

| Lane | Ask it directly |
| --- | --- |
| runpodctl | `runpodctl --help`, `runpodctl <resource> <action> --help`, `runpodctl version`. For failure shapes, run a command wrong on purpose and read the JSON |
| runpod-mcp | your client's tool list (`/mcp` in Claude Code); rules in [runpod-mcp](../runpod-mcp/SKILL.md#the-server-is-the-source-of-truth) |
| runpod-flash | `rp --help`, `rp flash <command> --help`, `pip show runpod`, and the dev/deploy output |
| runpod-companion-clis | that CLI's own `--help` (`hf`, `gh`, `docker`, `aws`) |
| runpod-templates | `runpodctl template list --type official`, `template get <id>` (its readme is authoritative) |
| REST v2 | the live spec at `https://api.runpod.io/v2/openapi.json` |

**Never tell a user a tool cannot do something without checking first.** A missing capability
is the claim most likely to be out of date here, and it is the one a reader has no reason to
reverify — it has already gone stale twice (runpodctl v2.9.0 added `serverless health`, v2.10.0
added `pod logs`/`serverless logs`). If a limit still holds, name the version it holds for
rather than saying "cannot".

## Before the first command

- **Update the CLI you are about to use** (`runpodctl update`, `rp update`; the MCP needs
  no step). runpodctl before v2.12.0 accepts `--stop-after`/`--terminate-after`, which the
  backend never enforced, so pods kept billing past the deadline.
- **Check the control plane before infra work**: `runpodctl user` succeeds, or `/mcp` shows
  `runpod` **Connected**. If neither works, help the user set up rather than limping on.
- **MCP OAuth first, a key only when a task needs one**: get `RUNPOD_API_KEY` (`rp login`
  with a human at an interactive terminal, else `export`) at the first CLI-only step; with no user in
  the loop, use the key from the start. Companion CLIs use their **own** credentials, never
  `RUNPOD_API_KEY`.

Details, install commands and the per-lane key table:
[`getting-started.md`](../runpod-usage/reference/getting-started.md).

## How to route

**0. Does a worked example already cover this?** For anything beyond a single call,
check [the golden-paths index](#worked-examples-golden-paths) *before* picking a lane —
a matching path already names the lane(s), the flags, the ordering, and the traps, so
routing becomes reading rather than re-deriving. Check it when **any** of these is true:

- the task needs **more than one resource** (image + template + endpoint, pod + volume,
  multi-region, …) or **more than one lane**
- it **provisions something billable**, or the user's ask is shaped like *"get X running /
  deployed / working"*
- it involves **storage, networking, autoscaling, streaming, or debugging a live resource** —
  the areas where the non-obvious ordering is the whole difficulty
- you are about to write a **multi-step plan** for it

Skip step 0 for a single read or a single CRUD call ("list my pods", "stop pod X",
"what GPUs are available") — go straight to the lane. **A matching golden path outranks
this router's lane table for workflow selection**. Its commands do not establish that a
capability is CLI-only: choose the execution lane from the live tool surface and the
capability matrix below, while preserving the path's ordering and verification steps.

For an explicit request to create or optimize a Dockerfile/template project, match
[path 26](./golden-paths/26-template-project/README.md) before generic deployment examples;
GP26 is an authoring specification with local checks, not a live-verified deployment.
An existing prebuilt does not replace the requested deliverable.

1. **Conceptual question, or an unmade design choice** (serverless vs pod? which
   GPU? bake the model or mount a volume?) → read **runpod-usage** first, then
   continue with the answer.
2. **Author or improve a template project / Dockerfile**, including converting local
   code or a GitHub repository, or prepare its Hub listing files → **runpod-build-template**.
   It delegates build/push mechanics and infrastructure work to their existing lanes.
   Registering an already-built image as a reusable template ("make a template from
   my image") and browsing/deploying an existing Hub listing use the infrastructure
   lanes below; registration needs no new Dockerfile.
3. **Run a common workload on a pod, or fix a template pod** ("run ComfyUI /
   PyTorch dev box", won't boot, missing models) → **runpod-templates** — check for
   an official prebuilt before planning any install, and let it route repairs.
4. **Write/iterate/ship your own code on Runpod GPUs using its code-first workflow** → **runpod-flash**.
5. **Produce an artifact** (download a model, build+push an image, create a repo
   release, sync data to a volume) → **runpod-companion-clis**.
6. **Migrate existing code between Runpod API versions** — "move us to REST v2",
   "which Runpod API is this repo on?", "what breaks if we upgrade?" →
   **runpod-migrate**. (Calling the API to *do* something is a different job; that
   is the infra lanes below.)
7. **Manage infrastructure** (create/list/update/delete pods, endpoints,
   templates, volumes; list GPUs/data centers; run a serverless job; billing):
   - A capability only the CLI has (the runpodctl rows of the matrix below) → **runpodctl**.
   - Otherwise, if the Runpod **MCP tools are connected** in this session
     (`create-pod`, `list-endpoints`, … are available) → **runpod-mcp**.
   - Otherwise (shell-only agent, no MCP) → **runpodctl**.

### runpod-mcp vs runpodctl (the overlap)

Both drive the same Runpod API, so they overlap on infra CRUD. Choose by
**capability first, environment second**:

- **MCP wins on convenience** for simple, structured operations — reads and basic
  CRUD — when its tools are connected (typed params, no shell quoting).
- **runpodctl takes over when an operation needs a capability MCP lacks** — even
  if MCP is connected — and is the only option for a shell-only agent or when the
  user wants a reproducible command.

Capability matrix (pick the preferred lane per operation):

| Operation | Preferred lane | Why |
| --- | --- | --- |
| List/get anything; start/stop/restart/delete a pod; simple CRUD on endpoints, templates, volumes, registries; catalog; billing | **runpod-mcp** if connected, else runpodctl | Simple structured ops — MCP is typed and convenient |
| Create a **simple** pod (one image + one GPU) | **runpod-mcp** if connected, else runpodctl | Both handle it |
| Create a pod **from a template**, a **CPU** pod, or both together | **runpod-mcp** if connected, else runpodctl | MCP's create-pod takes `templateId` and, for CPU, a `cpu` object in place of `gpu`; template + CPU in one create live-verified 2026-10-29. runpodctl v3 sends the same v2 create, so it is no fallback. Field semantics: [runpod-mcp pod creates](../runpod-mcp/SKILL.md#use-mcp-vs-runpodctl) |
| Create a pod with a **multi-GPU priority list** | **neither**: one GPU type per create | v2 `create-pod` takes one `gpu.id`, and runpodctl rejects a comma list in `--gpu-id` (`only one gpu id is supported`; checked through v3.0.1). Pick one type from the stock read; on a capacity error, retry with the next |
| Browse or deploy an existing **Hub** listing | **runpod-mcp** if connected and it exposes the requested operation, else runpodctl | Check the live tool surface; Hub is not a reason by itself to switch to the CLI |
| **File transfer** (`send`/`receive`, `network-volume upload`/`download`), **SSH** keys/info, **`doctor`** setup, **model** cache | **runpodctl** | MCP has no tool for these |
| Invoke a serverless job (`run`/`runsync`/status/stream) | **runpod-mcp** if connected, else runpodctl | Both lanes have first-class job commands now (runpodctl `serverless run`/`status`/`health`, v2.9.0+); MCP is typed, and only MCP streams a job's incremental output (`stream-job`) |
| Read **pod or worker logs** | **either** — runpod-mcp if connected, else runpodctl | Both lanes read them: MCP `stream-pod-logs`/`stream-worker-logs` return parsed frames; runpodctl `pod logs`/`serverless logs` emit json lines and `--follow` (v2.10.0+) |

Rule of thumb: **default to MCP for the easy stuff, hand off to runpodctl the
moment an op needs a flag/feature MCP doesn't expose.**

## Deploying a workload (the golden loop)

For any "get <X> running on Runpod" task, follow
[`development-loop.md`](../runpod-usage/reference/development-loop.md): decide pod vs
serverless → provision → set up (only if from-scratch) → verify → deliver → cost-guard +
teardown. Its binding rules, in one line each: **prefer a prebuilt
template / Hub worker** unless the user asked for a custom template project; **pin the CUDA
floor** on every GPU create (`--min-cuda-version 12.8` / `gpu.minCudaVersion: "12.8"`, `13.0` only for a CUDA-13 image; without it an
image can land on a host too old for it and die at startup or silently run on CPU;
[why](../runpod-usage/reference/gpu-selection.md#step-3-pin-the-cuda-floor)); **default to
Secure Cloud**; **cache vs network volume is a latency call** (download time is not billed, but a cache miss
holds the worker start, so the job queues and the endpoint looks idle); **stock picks the data
center, the network volume follows** (read per-data-center GPU stock, create the volume once
where the GPU is, and on a stock refusal keep it: retry once there or let the user choose;
[why](../runpod-usage/reference/storage.md#default-prefer-a-network-volume)); and **verify with a real
request from outside before delivering** — "Running"/"ready" does not mean serving.

It branches to two sub-loops:

- **Service you open at a URL** (Ollama, ComfyUI, dev box) →
  [`runpod-usage/reference/pod-workflows.md`](../runpod-usage/reference/pod-workflows.md)
  (ports + env + volume at creation, SSH-exec install, bind `0.0.0.0`, poll the
  proxy URL). Execute in the runpodctl lane.
- **Request/response API that scales to zero** (Whisper, inference) →
  [`runpod-usage/reference/endpoint-workflows.md`](../runpod-usage/reference/endpoint-workflows.md)
  (Hub worker vs flash vs custom image; invoke `/run`/`/runsync`; poll job status).

## Worked examples (golden paths)

This is **step 0 of routing**, not an appendix. Two dozen end-to-end scenarios live in
[`./golden-paths/README.md`](./golden-paths/README.md), each with a status header
(live-verified with a date, spec-checked, or legacy; check it before trusting a path), the
real commands and observed output, plus a Gotchas and a Cost & cleanup section, which is
the part that is expensive to rediscover.

**Match the task to a row below and open that path before you plan or call anything.**
A partial match is still worth opening: the closest path's ordering and gotchas usually
transfer even when the model, GPU, or region does not. Only fall through to the lane
tables above when nothing here is close.

| Want to… | Golden path |
| --- | --- |
| Run a server (Ollama/ComfyUI) on a pod at a URL | [01](./golden-paths/01-ollama-pod/README.md), [02](./golden-paths/02-comfyui-pod/README.md) |
| Deploy a serverless model endpoint (Hub / flash / custom image) | [03](./golden-paths/03-whisper-endpoint/README.md), [05](./golden-paths/05-model-to-endpoint-pipeline.md) |
| Serve an LLM with vLLM (Pod, load-balancing or Hub queue endpoint) | [27 — vLLM Pod → endpoint](./golden-paths/27-vllm-pod-to-endpoint.md); procedure in [runpod-vllm](../runpod-vllm/SKILL.md) |
| Install vLLM or ComfyUI privately on a Pod you already run (pinned, loopback, API-driven) | vLLM: [runpod-vllm existing-pod](../runpod-vllm/reference/existing-pod.md); ComfyUI: [02 Variant C](./golden-paths/02-comfyui-pod/variant-c-pinned-api.md) |
| Serve a HuggingFace model without baking it in or a volume (host-cached) | [20 — model caching (`--model-reference`)](./golden-paths/20-model-caching-endpoint.md) |
| Call a ready hosted model (no deploy) | [11 — Public Endpoints](./golden-paths/11-public-endpoints.md) |
| Fine-tune, then serve the result | [04](./golden-paths/04-finetune-pod.md), [08](./golden-paths/08-finetune-to-serverless.md) |
| Interactive dev box (SSH / VS Code) | [06](./golden-paths/06-dev-pod.md) |
| Move data pod → volume → serverless | [07](./golden-paths/07-network-volume-handoff.md) |
| **Custom serverless when flash isn't enough** (dual-mode image dev loop) | [09](./golden-paths/09-custom-serverless-dev-loop/README.md) |
| Create or improve a complete template project from code, a repo or an app request | [26 — project authoring](./golden-paths/26-template-project/README.md) |
| Build a minimal image for a target (pod vs serverless queue) | [22 (pod)](./golden-paths/22-minimal-pod-image/README.md), [23 (queue)](./golden-paths/23-minimal-queue-image/README.md); concepts in [building-images](../runpod-usage/reference/building-images.md) |
| Decide what to bake into the image vs mount on a network volume | [25 — bake vs mount](./golden-paths/25-bake-vs-mount/README.md) |
| Pick a network-volume **storage tier** (standard vs high-performance) | [21 — storage tiers](./golden-paths/21-storage-tiers.md) |
| **High availability / multi-region** serverless (multi-volume + data sync) | [10](./golden-paths/10-multi-region-ha-serverless.md), [19 (3-region)](./golden-paths/19-three-region-same-file.md) |
| Stream output incrementally (`/stream`) | [12](./golden-paths/12-serverless-streaming.md) |
| Tune autoscaling / raise per-worker throughput | [13 (autoscaling)](./golden-paths/13-autoscaling-tuning.md), [18 (concurrency)](./golden-paths/18-concurrent-handler.md) |
| Load-balancing / HTTP-server or WebSocket worker | [14 (LB)](./golden-paths/14-load-balancing-endpoint.md), [17 (WebSocket)](./golden-paths/17-serverless-websocket.md) |
| Get notified on job completion (push, not poll) | [16 — webhooks](./golden-paths/16-serverless-webhooks.md) |
| Check health / debug a failing endpoint | [15 — monitor & debug](./golden-paths/15-monitor-and-debug.md) |

## Multi-lane tasks

Sequence is always **understand → produce artifacts → manage infra → verify**,
because infra can only reference artifacts that already exist. Keep each step in
one lane, and switch lanes at credential boundaries.

Example — "deploy `openai/gpt-oss-20b` to a serverless endpoint":
1. **runpod-usage** — serverless vs pod, GPU tier for 20B, bake vs mount vs cache.
2. **runpod-companion-clis** — `hf download …`, `docker build --platform=linux/amd64 …`, `docker push`.
3. **runpod-mcp** or **runpodctl** — create the endpoint referencing the image + GPU pool.
4. Same infra lane — invoke the endpoint / check status to verify.

© runpod · Apache-2.0 · runpod/runpod-plugins-official

Similar skills

All skills for Cloud: AWS, Azure, GCP →

runpod by other authors comes first.

runpod digitalsamba A skill for running open-source AI models on cloud GPUs through RunPod serverless. Useful when a job needs more VRAM than your machine has. CX Codex +1 1,400installs runpod-vllm-claude-code marks97 runpod-vllm-claude-code deploys HuggingFace models to RunPod via vLLM and bridges them to Claude Code through a translation proxy. Verifies tool-calling support before tearing down disposable GPU pods. CX Codex +1 1,400installs modal-serverless-gpu Orchestra Research modal-serverless-gpu — a skill for running ML workloads on Modal's serverless GPUs: training, inference, batch jobs. Useful when you'd rather not manage a cluster yourself. CX Codex +1 1,100installs serverless-modal wanshuiyin serverless-modal runs GPU training and inference on Modal without SSH or Docker configuration. Prepares launcher scripts and estimates compute cost right inside your agent. CX Codex +1 515installs digitalocean-compute bobmatnyc Tells your agent which DigitalOcean compute to use for a job: Droplets, App Platform, Functions, DOKS or GPUs. Handy when you are deciding where an app or container should run. CX Codex +1 435installs vastai-sdk vast-ai vastai-sdk — a skill that gives the agent a reference for the Vast.ai Python SDK: GPU instances, volumes and serverless endpoints. Useful when you rent GPUs and script the setup. CX Codex +1 382installs modal K-Dense-AI Guides Python workloads on Modal, from web endpoints to GPU model training. Use it when deploying cloud jobs through the Modal SDK. CX Codex +1 2,100installs

From the same set18

The whole set →
flash Writes and deploys Runpod Serverless with runpod-flash: @Endpoint decorators, local iteration, and shipping endpoints. CX Codex +1 14,700installs runpod-mcp Controls Runpod infrastructure via the Runpod MCP server. Handles requests for pods, serverless endpoints, templates, network volumes, and GPU catalog checks. CX Codex +1 14,500installs runpod-usage runpod-usage — a skill for Claude Code that explains Runpod architecture and workload choices. It covers Pods, Serverless, GPUs, storage, networking, and image builds. CX Codex +1 14,500installs companion-clis companion-clis is a skill that guides agents through HuggingFace, GitHub, Docker, and AWS CLIs for Runpod tasks involving models, repositories, images, and network volumes. CX Codex +1 14,300installs runpod-migrate runpod-migrate migrates Runpod GraphQL API and REST v1 code to REST v2, locating call sites and breaking changes. Use it before an API upgrade or to identify the API generation in a repository. CX Codex +1 12,800installs runpod-templates runpod-templates — a skill for Claude Code, Codex, Cursor and other AI editors that lets you discover, understand, and deploy official Runpod Pod templates, with tools to repair ComfyUI workflow model metadata. CX Codex +1 12,100installs serverless-deploy serverless-deploy is a Claude Code skill that deploys an existing model, workflow, or container to Runpod Serverless and tests the endpoint with a real job. CX Codex +1 3,700installs pod-deploy pod-deploy provisions a GPU or CPU machine on Runpod and returns the working address. Confirms GPU class availability in the target data center before creating the Pod. CX Codex +1 3,700installs

Project sponsors

Companies that keep this analytics open