--- title: Skills | Runware Docs url: https://runware.ai/docs/platform/skills description: Give your AI agent packaged, outcome-oriented recipes for Runware. Ask for a result in plain language, the right skill routes to the right model, and the agent runs it through the SDKs, MCP, or CLI. relatedDocuments: - https://runware.ai/docs/platform/mcp - https://runware.ai/docs/platform/cli - https://runware.ai/docs/platform/typescript --- ## Introduction Runware Skills are packaged recipes that let an AI agent get good results from Runware without knowing the catalog. Each skill is a small folder of Markdown an agent loads on demand. You ask for an outcome in plain language, the matching skill picks up the request and chooses the right model, and the agent runs it to produce the result. The point is the routing. You ask for "a product video" or "the same character in a new scene" the same way today and a year from now. The skill decides which model fits, and that choice updates as better models ship. The skill is the stable part. The model underneath is free to change. You ask Make a launch video from this product photo A skill picks up the intent `product-ad-video` Named by the outcome, not the model. This is the stable part. It routes to the best model available today bytedance:seedance@2.0google:3@2klingai:kling-video@3.0-turbo Swappable underneath. When a better model ships, the skill's routing updates and every user gets the upgrade without changing a thing. Runs and returns `videoURL` with your finished clip Skills run on top of what you already have. A skill is instructions an agent loads, not a new endpoint, so there is nothing to host. Your agent reads the skill and carries out the work through the Runware access it already has: the [MCP server](https://runware.ai/docs/platform/mcp), the [CLI](https://runware.ai/docs/platform/cli), or the SDKs. ## How skills work A skill is a folder with a `SKILL.md` file. The frontmatter `description` is the trigger. It lists the phrases that should activate the skill, and the agent matches your request against it. When a request matches, the agent reads the skill body and follows it. Skills load on demand, so the cost of having many installed is small. Until a request matches, only a skill's name and description sit in the agent's context. Then the body loads. Deeper material such as worked examples loads only if the task calls for it. You can install the whole catalog and pay almost nothing until one applies. The set has two layers: - **Foundation skills** hold the shared machinery. How to call the API, how to pick a model, how to prompt. - **Outcome skills** are the customer recipes. Each one composes the foundation and adds the craft for its specific job. > [!NOTE] > A skill never hardcodes a single model as the only answer. It names a sensible default, then confirms the model is live and reads its current schema before running. That is what keeps a skill correct as the catalog changes underneath it. ## Add skills to your agent Skills are files. Add the ones you want wherever your agent loads skills from. **Claude Code**: 1 Add the marketplace Register the Runware marketplace, then install the skills plugin: ```bash /plugin marketplace add runware/runware-skills /plugin install skills@runware ``` You stay current as new commits land. 2 Or copy by hand To cherry-pick individual skills instead, clone the repo and drop the folders you want into `.claude/skills/` (or `~/.claude/skills/` for every project): ```bash git clone https://github.com/runware/runware-skills.git mkdir -p .claude/skills cp -r runware-skills/skills/product-ad-video .claude/skills/ ``` 3 Ask for the outcome Start a session and ask in plain language. The matching skill activates from its description. **Claude.ai**: 1 Open Skills On a plan with Skills, go to **Customize → Skills**. [Open Claude skills](https://claude.ai/customize/skills) 2 Upload the skill folders Upload the skills you want. Each becomes available to Claude in chat and activates when your request matches its description. **Cursor**: 1 Clone the repository ```bash git clone https://github.com/runware/runware-skills.git ``` 2 Copy the skills into Cursor Drop the skill folders into `.cursor/skills/` in your project, or `~/.cursor/skills/` for every project. Cursor reads the standard `SKILL.md` and discovers them recursively: ```bash mkdir -p .cursor/skills cp -r runware-skills/skills/* .cursor/skills/ ``` 3 Use a skill Ask in plain language and Cursor applies the matching skill, or type `/` and pick it by name. **OpenClaw**: 1 Install from the repo OpenClaw installs the skills straight from the repository: ```bash openclaw skills install git:runware/runware-skills ``` This adds them to the workspace `skills/` directory. Add `--global` for `~/.openclaw/skills`. 2 Ask for the outcome Start a session and ask in plain language. The matching skill activates from its description. **Any agent**: 1 Get the skills ```bash git clone https://github.com/runware/runware-skills.git ``` 2 Point your agent at them The skills follow the open Agent Skills standard, so any agent that supports skills can read them. Drop the folders wherever that agent looks, commonly `.agents/skills/` (or `~/.agents/skills/` globally), and it picks them up by their `name` and `description`. Pair skills with the [MCP server](https://runware.ai/docs/platform/mcp) or the [CLI](https://runware.ai/docs/platform/cli) so the agent has a way to actually run the tasks the skill describes. ## The catalog Three foundation skills carry the shared machinery. Every outcome skill leans on them. `runware-run` The execution contract. Inspect the model's schema, send only valid fields, run synchronously for images or asynchronously for video, audio, and 3D, then read the result. `runware-models` Pick the right model for a task and keep that choice current. Discovers what is live, routes by capability, and respects deprecations. `runware-prompting` Per-model-family prompt craft. In-image text, negation, and cinematic grammar, matched to how each model reads a prompt. The outcome skills are grouped by what they make. **Image** - `product-photography` turns a packshot into studio, lifestyle, and hero shots. - `character-consistency` keeps a character or product identical across scenes. - `text-in-image` renders posters, packaging, and UI with exact copy. - `edit-image` adds, removes, replaces, recolors, relights, inpaints, and outpaints. - `restore-and-upscale` deblurs, denoises, upscales, and restores old photos. - `photoreal-stills` produces realistic, non-AI-looking imagery. - `composite-scene` merges a product, a subject, and a backdrop without masking. - `logos-and-vectors` makes true SVG logos, icons, and scalable art. - `controlled-generation` drives generation from a pose, edge, or depth guide. - `game-assets-2d` makes sprites, stickers, and consistent asset sets. **Video** - `product-ad-video` turns a product image into an ad clip. - `ugc-ad` makes creator-style demos, testimonials, and talking-head ads. - `animate-image` turns a still into motion. - `talking-avatar` drives a talking head from a script or audio. - `multi-shot-video` tells a multi-shot story in one call. - `cinematic-video` directs shot language and color grade. - `edit-video` transforms, restyles, or surgically edits footage. - `replace-in-video` swaps a character, product, or wardrobe in a clip. - `reframe-video` changes aspect ratio without cropping. - `add-audio-to-video` adds sound effects, narration, or a music bed. - `video-upscale` increases resolution toward 4K. **3D, audio, and text** - `image-to-3d-asset` turns a photo or prompt into a textured GLB mesh. - `voiceover` generates TTS narration with emotion and voice control. - `dialogue-audio` produces a multi-speaker conversation in one file. - `voice-cloning` clones a voice from a sample or designs one. - `music` makes songs, instrumental beds, and jingles. - `llm-agent` builds chat and tool-calling over your own functions. - `vision-understanding` reads images, video, and documents. **Custom models** - `train-style-model` fine-tunes a reusable brand or style LoRA. - `bring-your-own-model` uploads and uses your own LoRA or checkpoint. ## Anatomy of a skill Every skill follows the same shape. The frontmatter is the trigger, and the body is the recipe. ```markdown --- name: product-ad-video description: > Make an ad or promo video from a product image. Use for "turn this product photo into a video", "launch clip", "product ad". --- # Product ad video ## Inputs to collect ## Models ## Workflow ## Technique ## Parameters that matter ## Quality bar ## Related skills ``` `Models` names a default plus alternatives and tells the agent to confirm the model is live. `Technique` carries the craft, drawn from the model's own guide. `Parameters that matter` lists only the load-bearing fields and points at the live schema for the rest, so the skill does not go stale when a model updates. Flagship skills add a `references/` folder with worked examples that load only when needed. ## What an agent does with one Give an agent the skills and a single sentence. > Restore this old family photo and make it print-ready. The agent matches the request to `restore-and-upscale`, reads it, picks an upscaler that is live, runs the task, and returns the result. The skill also tells it the honest limit: there is no dedicated face-restoration model yet, so it sets that expectation instead of overpromising. > Make a launch video from this product shot, vertical, with a voiceover. Two skills compose. `product-ad-video` animates the product and `voiceover` generates the narration. The agent runs the video asynchronously, polls for the result, and hands back the clip. You did not name a model or a parameter. ## Write your own A skill is just a folder: a `SKILL.md` with a name and a description in the frontmatter, then the instructions, plus an optional `references/` for depth. The fastest start is to copy a skill from the [`runware-skills`](https://github.com/runware/runware-skills) repo and adapt it to your outcome. Two things carry most of the weight. Name the skill by the **outcome**, not the model, so the model underneath can change without breaking the skill. And treat the **description as the trigger**: lead with the phrases a user would actually say, because that line is what the agent matches a request against. Point the technique at a sensible model, but have the skill confirm the model is live before relying on it, so it stays correct as the catalog moves. ## How skills relate to the rest of the platform Skills are the know-how. They decide what to do and how to do it well. The agent runs the work through the [SDKs](https://runware.ai/docs/platform/typescript), the [MCP server](https://runware.ai/docs/platform/mcp), or the [CLI](https://runware.ai/docs/platform/cli). A skill points the agent at a model and a set of parameters, and one of those surfaces makes the call. Use skills when you want the agent to reach a result without you scripting the steps. Use the SDKs, MCP, or CLI directly when you want to drive the API yourself.