Scenario's agent skills teach a coding agent to drive its generation API

Seventy-one skills that teach an agent to drive one API

The scenario-labs/skills repository publishes Agent Skills for AI coding agents, and the README names the supported agents as Claude Code, Cursor, Codex, Copilot, and 70 or more others. The skills follow the Agent Skills format, and the site is skills.sh, where the project has its own page.

What the skills do is described in one long sentence: they teach agents to create production-ready content with Scenario through the Scenario MCP server, covering images, video, audio, textures, skyboxes, 3D assets and custom-trained models, for games, entertainment and any creative vertical. The MCP server documentation and the API documentation are both linked from the header, along with the app documentation, which tells you the three layers are distinct: the MCP server is what the agent talks to, the API is what that server is built on, and the app is what a human uses.

The structure is worth understanding because it is not a library. There are no Python modules to import and no API to code against. Each skill is a document the agent reads, and the repository is mostly markdown plus the scripts that check it. The primary language is listed as Python because the validation scripts are Python, and the ruff.toml at the top of the tree is the linter configuration for them.

The agent-facing entry points are the interesting part of the repository layout. There is a .claude/ directory and a .claude-plugin/ directory for Claude Code, a .codex/ directory for Codex, and an .agents/ directory, plus AGENTS.md, CLAUDE.md and a skills.sh.json manifest. The same content is presented to several agent ecosystems, which is why the scripts/ directory contains a sync-agent-commands step that keeps them in step and a check mode that fails the build when they drift.

Releases are frequent: skills-v0.54.0 on 2026-10-10, v0.55.0 on 2026-10-11 and v0.56.0 on 2026-10-14, matching the last push date.

Installing a curated set rather than the whole list

The install section is built around npx skills add, and the argument is the interesting part. Rather than one command that installs everything, the README offers several, each a set of --skill flags naming a specific group.

The default is everything for Scenario without the expert tools, all 71 Scenario skills. Then there is a shorter command for game art and 3D, described as 22 skills covering sprites, tilesets, textures, skyboxes, 3D props and walkable spaces in one consistent style:

npx skills add scenario-labs/skills --skill scenario --skill scenario-game-assets --skill scenario-sprite-animation --skill scenario-side-view-game-kit --skill scenario-textures --skill scenario-skyboxes --skill scenario-3d --skill scenario-image --skill scenario-patina-retexture --skill scenario-walkable-room --skill scenario-video --skill scenario-consistency --skill scenario-model-training --skill scenario-refine-loop --skill scenario-moderation --skill scenario-meshy --skill scenario-rodin --skill scenario-sparc3d --skill scenario-3d-worlds --skill scenario-gemini-image --skill scenario-audio --skill scenario-sonilo

And one for marketing and brand visuals, also 22 skills, where one product shot and a brief turn into on-brand stills, ads, UGC videos and every placement size:

npx skills add scenario-labs/skills --skill scenario --skill scenario-product-shots --skill scenario-brand-kit --skill scenario-video-ads --skill scenario-ugc --skill scenario-formats --skill scenario-inspiration --skill scenario-image --skill scenario-image-editing --skill scenario-text-overlay --skill scenario-video --skill scenario-video-editing --skill scenario-audio --skill scenario-video-assembly --skill scenario-consistency --skill scenario-asset-analysis --skill scenario-veo --skill scenario-seedance --skill scenario-kling --skill scenario-elevenlabs --skill scenario-ad-variants --skill scenario-thumbnails

The counts are in the README rather than in the commands, which is helpful, because the command is long and the number of skills is the thing you actually want to know before pasting it.

Two further groupings are described. By role, INSTALL.md groups the skills by job from 2D artist to producer, with the outcomes each role gets and one command per role. By goal, each command installs the lead skills for one outcome plus the sibling skills they hand work to. The difference matters: the by-goal sets are for a task, the by-role sets are for a person, and they are not the same lists.

The skill names are a map of what the API can do

Reading the skill names is the fastest way to understand the coverage, because the naming is descriptive rather than abstract.

There is a group per model family, which tells you the model routing is the point. The image skills include scenario-gpt-image, scenario-mai-image, scenario-seedream, scenario-gemini-image, scenario-reve, scenario-ideogram, scenario-grok-imagine-image and scenario-luma-image. The video skills include scenario-minimax-video, scenario-gemini-omni, scenario-grok-imagine-video, scenario-veo, scenario-seedance, scenario-kling, scenario-vidu, scenario-wan, scenario-runway and scenario-luma-video. The audio skills include scenario-minimax-music, scenario-elevenlabs, scenario-ace-step and scenario-sonilo. And there is a three dimensional group with scenario-meshy, scenario-rodin, scenario-sparc3d and scenario-3d-worlds.

Then there is the workflow group, and these names describe a production process rather than a capability. scenario-quality-gate and scenario-refine-loop are the review and iteration cycle. scenario-consistency and scenario-identity-library and scenario-brand-kit are the character and brand continuity machinery, which is the thing the description means by keeping characters and brands consistent. scenario-model-training is custom training, scenario-model-comparison and scenario-formats and scenario-workflows and scenario-workflow-authoring are the abstraction layers above individual models. scenario-report, scenario-team-admin, scenario-admin-analytics and scenario-moderation are the operational side. And scenario-asset-analysis is the step that looks at what you already have.

There is a whole sub-family named after a consumer product, scenario-chatgpt-pet-create and scenario-chatgpt-pet-update, which is a curiosity worth noting as evidence that the skill set follows demand rather than a tidy taxonomy.

The description in the repository header says the skills pick the right model, price before spending, and keep characters and brands consistent through the Scenario MCP. So the routing, the cost estimate and the consistency handling are the three behaviours these documents encode.

The expert teams are a different mechanism entirely

The README draws a clear line between the two halves of the repository, and it is the line between using a hosted API and driving local software.

The expert tools at the bottom of the list are described as teams of skills that drive DCC, digital content creation, software and game engines installed on your machine, including ZBrush, Blender, Maya, Unreal Engine, Unity and Godot, distilled from expert tutorials, conference talks and official documentation.

They need the application, not the Scenario MCP server. That is the whole difference, and it changes what they are for. The Scenario half needs an API key and a network connection. The expert half needs Blender or Unreal or ZBrush installed and running on your machine, and the skill is essentially a distilled procedure telling the agent how to drive that application's own interface.

The provenance is stated too, which is unusual and useful. The skills are distilled from expert tutorials, conference talks and official documentation, and each family folder's README records how it was built and how far it was verified. That last part is the detail that matters in practice. A skill that automates a piece of software through its own UI or its own scripting interface will break when the software changes, and a README that tells you how far the automation was tested tells you whether you are looking at a well-covered path or a demonstration.

The repository topics list the engines and tools individually, with blender, maya, zbrush, unreal-engine, unity, game-development and gamedev among them, alongside the generation side of mcp, model-context-protocol, image-generation, video-generation and 3d-generation.

The practical consequence is that the two halves have different failure modes and different setup costs, and installing all of them is not a sensible move.

The repository is mostly a validation pipeline

The package.json for this repository is a quality gate, and that is what a skills repository is once the content is written.

The package is private, uses pnpm 11.21.0 as its package manager, and the validate script chains a long list of checks: style, format:check, sync:agent-commands:check, skill-files, lint:py, groupings, manifest:check, readme, words:check, spell and spec. Each has its own script, and each is a guard against a specific way the content drifts.

The style check is a shell script, and the format is prettier with a dedicated prettier-plugin-sh for shell scripts, which tells you the skills contain shell. The spell check uses cspell with a project-words.json and a words:sort script that keeps the custom dictionary sorted, and cspell.json at the top level configures it. The words file exists because a skills repository has a lot of proper nouns, model names and API identifiers that a general dictionary would flag.

The Python lint runs uvx ruff at a pinned version 0.16.10, and the ruff.toml holds its configuration. The skill file check is a shell script that verifies the structure of the skill files themselves, the groupings check is a node script that validates the groupings referenced in the README, the manifest generator produces the plugin manifest and can check it, and the spec validation runs a script over the skills.

The agent command sync is the interesting one. sync:agent-commands writes the commands that install skills into the agent-specific directories, and there is a check mode that fails if the checked-in copies are out of date, plus a node test for it. The same pattern appears for the manifest, which has its own generate and check pair and its own test.

Tests run the agent command sync, the manifest generation and the skill scripts, with vitest available as a dev dependency. Releases are cut by release-please, with a release-please-config.json, a .release-please-manifest.json and a version.txt, and commits follow conventional commits through commitlint with commitlint.config.js.

There is also a skills-lock.json, which is the lockfile for the skill set itself, and the pnpm-lock.yaml for the tooling. The top level has SECURITY.md, CODE_OF_CONDUCT.md, CONTRIBUTING.md, CHANGELOG.md and a .husky/ directory for the git hooks.

Editorial conclusion

Scenario's skills suit an agent user who wants the model to call a hosted generation API correctly, with the model choice, the pricing check and the consistency handling already written down, and they are the wrong tool if you need a self-hosted image pipeline. Before installing, read the grouping choices rather than taking all 71 skills, because the install commands are curated sets and the useful one depends on whether you are making game art, marketing visuals or video. Verify first that you are prepared to use a hosted commercial API, since these skills exist to drive Scenario's own service rather than a local model.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. scenario-labs/skills on GitHub