runpod-usage
runpod/runpod-plugins-official
Runpod concepts and workflows: pods vs serverless, GPU selection, container building, and the agentic development loop.
What is runpod-usage?
Reference knowledge for working with Runpod infrastructure—covering pod vs serverless deployment models, GPU/VRAM selection, Docker image building, storage, networking, and the iterative development loop (provision → ssh-exec → setup → verify). Use this to understand concepts and make informed choices; execute with runpod-mcp, runpodctl, or flash.
- Explains pod vs serverless architectures, workers, cold starts, and FlashBoot trade-offs
- Guides GPU and VRAM selection based on workload and cost
- Documents the agentic development loop: plan → prefer prebuilt → provision → verify → teardown
- Covers on-pod software installation hygiene (uv, apt, caching, non-interactive setup)
- Describes Docker image building for Runpod (handler contract, layering, platform specifics)
- Clarifies storage options: container disk, network volumes, model caching, and S3 access
How to install runpod-usage
npx skills add https://github.com/runpod/runpod-plugins-official --skill runpod-usageHow to use runpod-usage
- 1.Identify your question type (setup, architecture choice, image building, etc.)
- 2.Consult the matching reference file from the skill's table (getting-started.md, concepts.md, pod-workflows.md, etc.)
- 3.Read the relevant concept section to understand trade-offs and best practices
- 4.For end-to-end execution, follow the corresponding golden-path example
- 5.Execute infrastructure changes using runpod-mcp, runpodctl, flash, or companion-clis
Use cases
- Choosing between pod and serverless for a new workload
- Selecting the right GPU and VRAM for cost and performance
- Building and iterating a custom Docker image for Runpod
- Setting up and managing software dependencies on a pod
- Debugging networking, storage, or deployment issues
- ML engineers provisioning GPU workloads
- Developers building containerized applications for Runpod
- DevOps engineers managing infrastructure-as-code for cloud compute
- Anyone new to Runpod seeking conceptual grounding before executing
runpod-usage FAQ
It is a reference—it explains concepts and workflows but does not execute infrastructure changes. Use runpod-mcp, runpodctl, flash, or companion-clis to actually provision, configure, or deploy.
Read reference/concepts.md for the full comparison. Pods suit long-running or iterative workloads; serverless suits request-driven, stateless endpoints with variable load.
Start with reference/docker.md for the handler contract and Dockerfile basics, then reference/building-images.md for layering, base-image selection, and pod vs serverless deployment differences.
Plan → prefer prebuilt → provision → verify → teardown. See reference/development-loop.md for the full cycle, and reference/pod-workflows.md for the pod sub-loop (ssh-exec, setup, poll readiness).
Read reference/on-pod-setup.md for package hygiene, uv usage, non-interactive installation, and caching strategies to avoid common setup failures.
Full instructions (SKILL.md)
Source of truth, from runpod/runpod-plugins-official.
name: runpod-usage description: >- How Runpod works and how to work it — pods vs serverless, GPU/VRAM selection, storage, building a container, networking, plus the agentic pod development loop (provision → ssh-exec → set up → poll readiness) and on-pod install hygiene (uv/apt). Use to answer "how does X work", "which GPU", "how do I build a container", or "how do I stand up a workload on a pod". Guidance, not a tool — execute with runpodctl, runpod-mcp, or flash. metadata: author: runpod version: "1.4.0" # x-release-please-version license: Apache-2.0
Runpod usage (concepts)
Background knowledge for making the right choice before you act. This skill runs nothing — once you know what to do, execute with runpod-mcp/runpodctl (infra), flash (your own code), or companion-clis (models/images/data).
This skill explains; the golden paths demonstrate. When the question is really "how do I do X" rather than "how does X work", the verified end-to-end example is the faster answer — runpod/golden-paths/README.md. Read the concept here, then follow the path.
Read the one reference file that matches the question:
| Question | Read |
|---|---|
First-run setup / auth — get + set RUNPOD_API_KEY, SSH, companion creds | reference/getting-started.md |
| Pods vs serverless, workers, cold starts, FlashBoot, queue vs load-balanced | reference/concepts.md |
| The development loop for ANY workload (start here) — plan → prefer prebuilt → provision → verify → teardown | reference/development-loop.md |
| Stand up / iterate a workload on a pod — the pod sub-loop | reference/pod-workflows.md |
| Deploy / iterate a serverless endpoint — Hub vs flash vs custom, invoke + verify | reference/endpoint-workflows.md |
Install software on a pod — package hygiene, uv, non-interactive, caching | reference/on-pod-setup.md |
Build a Docker image Runpod can run (handler contract, Dockerfile, --platform=linux/amd64) | reference/docker.md |
| How to build an image well — base image, layering, bake-in vs volume, pod vs serverless (queue/LB) contract | reference/building-images.md |
| Where data lives — container disk vs network volume, model caching, S3 access | reference/storage.md |
| Which GPU / how much VRAM / cost & availability / data centers | reference/gpu-selection.md |
| Reaching a pod or endpoint over HTTP (proxy URLs, exposed ports) | reference/networking.md |
| Common mistakes and how to avoid them | reference/gotchas.md |
Related skills
More from runpod/runpod-plugins-official and the wider catalog.
runpodctl
Terminal CLI for managing Runpod GPU pods, serverless endpoints, volumes, and models.
companion-clis
HuggingFace, GitHub, Docker, and AWS CLIs for Runpod workflows.
flash
Code-first serverless: write Python locally, iterate with hot-reload on remote Runpod GPUs/CPUs, then deploy.
runpod
Router to Runpod skills—pick the right lane for pods, serverless, templates, CLI, or code.
companion-clis
Companion CLIs for Runpod workflows — HuggingFace, GitHub, Docker, and AWS.
flash
Deploy AI workloads on Runpod serverless GPUs/CPUs with hot-reload dev iteration and one-command shipping.