pexo-skills packages AI video production as agent skills with auto model selection

The pitch is a finished video, not a clip

The README is direct about the positioning. Pexo is described as a set of open-source agent skills for AI video production: you describe what you want, and Pexo selects the best model, names given as Seedance 2, Kling 3.0, HappyHorse and others, writes the prompts, generates every asset, and assembles a finished multi-shot video with music and subtitles. One API key, no prompt engineering, no video editing.

The comparison table in the Why Pexo section makes the intended reader clear. The columns are Pexo, single-model skills and generic wrappers, and the rows are models, auto model selection, input types, output, prompt engineering, multi-shot sequencing, lip sync and voice, and setup.

The numbers in that table are the differentiators. Pexo claims 10 or more models against 1 for a single-model skill and 2 or 3 for a generic wrapper. Auto model selection is a yes for Pexo and a no for both alternatives. Input types are five for Pexo, described as text, image, URL, script and audio, against 1 or 2 for the others. Output is a finished multi-shot video with music, subtitles and transitions, against a raw clip.

The setup row is the one that matters for an evaluator. Pexo needs one API key for all models, where the alternatives need one key per provider. That is the trade: you give up direct provider relationships and per-provider billing in exchange for a single integration point and a pipeline that has already been assembled.

The repository description calls the collection a set of open-source Agent Skills for content creation covering images, audio and video, and the badge in the README claims twenty skills.

Install paths for the three named agents

There are two documented installation routes, one per distribution channel.

The first goes through skills.sh.

npx skills add https://github.com/pexoai/pexo-skills --skill pexo-agent

The second goes through ClawHub.

openclaw skills install pexo-video-agent

Both install the same kind of artefact into different agents. The README lists compatibility with Claude Code, OpenClaw, Cursor, and any agent supporting the Agent Skills standard, which is the mechanism that makes the same skill definition portable across all of them.

The repository layout supports that portability claim. There are plugin directories for three specific agents, .claude-plugin, .codex-plugin and .cursor-plugin, alongside a skills directory, a scripts directory, a docs directory, a VERSION file and a CLAUDE.md.

The naming differs between the two channels, which is worth noting if you script the installation. The skills.sh route installs a skill named pexo-agent, and the ClawHub route installs one called pexo-video-agent. Those are different names for what the README describes as the same underlying thing.

For an agent that supports neither channel, the standard route is to clone the repository and point your agent at the skills directory. The CONTRIBUTING.md file covers contributions, and INSTALL.md and INSTALL_FOR_AGENTS.md are both present in the root, which suggests the project expects manual installs to be a normal path rather than an exception.

One agent skill, scenario shortcuts, and lower-level skills

The skills section describes the structure as a general agent, scenario specific shortcuts, and lower level creative and studio skills, with the important property that every skill works standalone and there are no dependencies between them.

That no-dependencies property is what makes the collection usable piecemeal. If you only want a specific job done, you install one scenario skill and you are not forced to pull in the full agent with its script, storyboard and render stages.

The main entry point is pexo-agent, described as the full video production agent: conversation to script to storyboard to render to music to subtitles to export, with auto model selection across 10 or more models, producing videos of 5 to 120 seconds in 16:9, 9:16 or 1:1.

The scenario skills are described as focused entry points to the same Pexo agent, with the guidance to install only the one that matches your task if you prefer a skill named for the exact job.

That structure has an obvious benefit and an obvious cost. The benefit is that a team can start with one narrow skill and grow. The cost is that the scenario skills and the general agent are two ways to reach the same underlying pipeline, and the README's own comparison table is about the pipeline rather than about the skills, so the skill taxonomy is a distribution decision layered on top of one product.

The README also notes the agent handles model selection, prompt engineering, generation and assembly, with the summary that you describe the result you want rather than the technical steps.

Five input types and the four workflows they serve

The example prompts section shows how much of the work the agent absorbs, and the workflows are worth reading as a spec of what the pipeline expects.

Product advertising: a 30-second video ad from a product photo, with upbeat background music and a voiceover highlighting key features, output in 9:16 for TikTok and 16:9 for YouTube.

Social content from a URL: go to a product page and create a 15-second Instagram Reel showcasing the product, using the images and description from the page. That implies the agent scrapes the page, which the What You Can Build section confirms for product ads, where it says Pexo scrapes the page, writes a script and generates shots.

Brand narrative: a 60-second brand story with a cinematic mood, warm color grading, four shots with smooth transitions and a gentle acoustic background track.

Batch production: five different 10-second video ad variants from one product image, each in a different visual style, minimal, bold, cinematic, playful, luxury, for A/B testing.

Script driven production: a script with six scenes turned into a finished video with TTS narration, one shot per scene and a lower third title card on the first shot.

Those five map onto the five input types the comparison table claims, text, image, URL, script and audio, and the batch case is the one that most clearly justifies a pipeline rather than a single call. Generating fifty product videos from a spreadsheet of images and descriptions is the kind of volume where hand-driving a model API stops being reasonable.

The aspect ratio support is consistent across the section: 16:9 for YouTube, 9:16 for TikTok and Instagram Reels, 1:1 for feed posts.

Rendering times are the number to plan around

The README gives two timing figures and one more in the feature section, and they are the only quantitative claims in the document.

A typical 15-second, 3-shot product ad renders in under 8 minutes. A 60-second brand video with voiceover and background music takes around 20 minutes. And in the What You Can Build section, a 30-second product ad with 3 shots and voiceover typically renders in under 10 minutes.

Those numbers are not about the models being fast. They are about the pipeline being sequential and about you waiting. Shot generation, then assembly, then music and subtitles, and a 60-second video contains four times as much footage as a 15-second one. If you are planning a batch of twenty variants, the arithmetic follows directly from the per-item figure.

The README does not say whether the pipeline is queued and pollable, whether there is a concurrency limit, or what happens when one shot in a multi-shot render fails. That is a real gap for anyone planning automation, and the Agent Skills format itself does not tell you, since the agent runs inside your coding session and the wait is the agent's to manage.

The one part of the pipeline the README does describe in detail is the post-production output. Lip sync and voice are built in, described in the comparison table as TTS, voice cloning and lip sync, and the post-processing side includes music, subtitles and transitions. The scenario list also mentions lower third title cards, so overlay text on a specific shot is part of the vocabulary.

The dependency on Pexo is the thing to decide on

The skills are open source, and the service behind them is not. That distinction matters and the README does not dress it up.

Every model the pipeline routes to, Seedance 2, Kling 3.0, HappyHorse and the rest, is reached through Pexo with one API key. The skill files are readable and adaptable, and the repository is MIT licensed, but the part that actually generates pixels is a commercial service.

So the open-source part is the orchestration: the prompt writing, the shot decomposition, the storyboarding, the assembly logic, the transitions and the subtitle handling. That is real engineering and it is the part that encodes the decisions a user would otherwise make, but it is orchestration rather than inference.

This has a practical consequence for the comparison in the README. The single-model alternative with one API key per provider gives you direct provider relationships, your own billing, and the ability to swap a model without changing anything but a string. Pexo replaces that with a single integration, automatic per-shot routing, and a finished asset.

Which side of that trade you should be on depends on whether you are producing videos as a byproduct of other work or whether video generation is the work. For the first case the single integration and the assembled output are worth a lot. For the second, where you are iterating on a specific look across many shots, losing direct model control and getting a black box router is a poor bargain.

The homepage recorded for the repository points at an invite link on the Pexo site, which suggests the service is the commercial product and the skills are the distribution channel.

Where pexo-skills is the wrong tool

The first limitation is the one above: you cannot change the model routing, the prompt strategy or the assembly logic without going through the service, so a specific creative requirement may be unmeetable rather than merely inconvenient.

The second is that the whole value proposition is short-form marketing and explainer video. The What You Can Build section names product video ads, TikTok, Instagram Reels and YouTube Shorts, brand and narrative videos, e-commerce content at scale, and explainer and tutorial videos. There is no mention of long-form content, and the pexo-agent skill caps at 120 seconds. A documentary or a lecture is out of scope.

The third is that the pipeline is opinionated. Script to storyboard to shot by shot to assembly is a particular shape, and the example prompts all conform to it. A video that needs a non-linear structure or a shot that does not fit the shot list is fighting the tool rather than using it.

The fourth is the agent as a dependency. The output depends on how your agent interprets your brief, which means the same prompt can produce different results across runs, across models and across agent versions. That is inherent to the design, but it makes reproducible output a matter of prompt discipline rather than a property of the tool.

The fifth is that the timings assume nothing goes wrong. The README documents no failure mode, no partial render recovery, no cost table and no rate limit, and for a pipeline that runs for twenty minutes per item and depends on a hosted service, those are the details you need before committing to a schedule.

How it compares with a direct model API call

The alternative is to call a video model directly and do the assembly yourself.

That approach gives you the whole pipeline in your own code. You pick the model, you write the prompt, you handle the shot list, you cut the clips, you time the subtitles, you mix the audio, and you call the render farm. For a team with existing video tooling, a house style and a publishing pipeline, that is often less work than it sounds, because the editing step is usually already automated.

It is also less work in a second sense. The skills approach still requires you to accept the orchestration Pexo has chosen. The orchestration is the differentiator and the constraint at the same time: it is why you get a finished video with music and subtitles from one instruction, and it is also why you cannot ask for a specific model on shot four.

There is a third path worth naming, which is a hybrid. Take the skill definitions, read them, and reimplement the parts you want against your own provider keys. The skills are open source and MIT licensed, and the skill format is a plain directory of instructions, so the orchestration logic is readable and portable. Someone who likes the shot decomposition but wants their own models can keep the first and replace the second.

The honest summary is that pexo-skills optimises for throughput of finished assets rather than for control of the process. If your problem is producing many videos quickly, it is built for you. If your problem is making one video exactly a certain way, you will spend the time fighting the pipeline instead of using it.

Editorial conclusion

pexo-skills fits a team with Claude Code, Cursor or OpenClaw that needs short marketing, product or explainer videos produced repeatedly and would rather describe an intent than drive a model API, and it fits a developer who wants to read and adapt the skill definitions themselves. It does not fit a team that needs the underlying model under its own control or a per-token cost model, because the whole pipeline runs as a service behind one Pexo API key. Before installing, read INSTALL.md and INSTALL_FOR_AGENTS.md, decide whether the pexo-agent skill or one of the scenario skills matches your task, and check the model list and the per-shot routing rules against the content you need, since auto model selection is the feature that carries most of the project's claims and is also the part you cannot tune directly.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. pexoai/pexo-skills on GitHub
4. Project website
5. README