THE AGENT SKILLS DIRECTORY
Reusable skills for AI agents. Install any of them into a Cohub world's agent with one command.
npx -y @neta-art/neta-search-cli@latest skills find "<what you need>"
Wrote a skill? Publish it here →
Basic Cohub abilities. Most agents already have these mounted; listed here for reference.
Paste this into your agent's chat — it fetches the skill and follows it.
Use the skill: short-video. Run `npx -y @neta-art/neta-search-cli@latest skills use neta-search/short-video --via site` and follow what it prints. Read its complete output, redirecting it to a temporary file first if necessary, and resolve relative paths from the skill directory it prints.npx -y @neta-art/neta-search-cli@latest skills use neta-search/short-videoMake a finished short video from your world's characters, places, and story moments.
# Short video
From an idea to one finished short video. This is the general case: any short the user describes that no format skill covers.
## Requirements
This skill only routes; the neta platform's `generate` skill owns video production.
- **Step 1, before any generation: ask the one question and end the turn** (see "One question first, always" below). This overrides the playbook's "only if the ask is vague": a detailed ask — named characters, references, style — still gets the question. Reading the skills below and the world first is fine; your first `generate` call (sheet, scene, board or video) comes only in a turn after the user has answered.
- Read `/mods/neta/.agents/skills/generate/SKILL.md`, then `/mods/neta/.agents/skills/generate/playbooks/video.md`, and follow the video playbook from its first state. It covers the one question to ask, the alignment package (script table, reference images, pitch board) that needs the user's single yes, and production and repairs.
- If `/mods/neta` does not exist in this world, tell the user video generation is not available here and stop.
## What this skill adds
- **Start from the world.** Use the world's characters, places and style as the cards the playbook asks for; prefer what the user selected or named.
- **Stay short.** Default to the playbook's shortest length unless the user asks for more.
- **One question first, always.** This skill always spends the playbook's one question — even when the ask looks complete. The first reply asks exactly one question in chat and ends the turn. Reading the world and its cards beforehand is fine. Generate nothing — no image, sheet, board or video — until the user answers.
- If the user named the question to ask, ask that one.
- Otherwise ask the one open choice that most changes the film, such as how it pays off, the ending beat or the length. Give two or three concrete options and your pick.
- Never re-ask what the user already gave. Don't run a separate questionnaire round; this one question is the round.
- Show the alignment package before generating any video — never skip it, even when the ask looks complete.
- The package reply ends on one plain status line — the film itself is not made yet — and one yes question, then the turn ends. Word that question so no change means go ("Anything to change, or shall I shoot it?"). A conditional go-ahead ("once I say yes, shoot it") still waits for that yes.
- Any reply to the package that asks for no change and does not refuse is the yes — "that's all", "looks good", "nothing to add", "thanks" included. Submit the video in that turn, then poll and hand over as below. Don't read it as a goodbye. Only an explicit no ("don't shoot", "stop", "not now") holds the shoot.
- Only when the user has already approved production without seeing the package ("don't wait for me, shoot it after the package"), that is the yes: show the package and submit the video in the same turn.
- The same holds when the answer to the one question also tells you to proceed — it doesn't just pick an option, it adds a go-ahead such as "go ahead", "continue", "just make it", "继续吧", "直接做". That answer is the single yes. Show the package and submit the video in that same turn, then poll and hand over as below. Don't make the user approve twice. A bare pick ("option 2", "let's go with the second one") is not a go-ahead. That still waits for the package yes.
- A bare approval that names no option ("可以", "行", "ok", "yes") is different. This matters most when it is the word the user, or your question, said would start the shoot. It accepts your stated pick and is also the single yes, so show the package and submit the video in that same turn. Never end that turn on the package and wait for that word a second time.
## Deliverable and boundary
- **The deliverable is one video Work.** The alignment package (script table, reference images, pitch board) is part of this skill's contract. It is alignment material shown inside the reply, not an extra product.
- Embed the package images by their CDN urls.
- Don't download, copy, rename or save them as files (no `pitch-board.png` and the like).
- Don't hand them over as Works. Every `generate image` still saves an image Work, so give package images a `--work-title` that reads as alignment material (film title + "alignment package" + what it is, in the user's language). They never count as the film; until the video Work exists, nothing has been delivered.
- Make no other stills, pages or files.
- Name the video Work with `--work-title` on the `generate video` submit. Keep the `taskRunId` and `outputs[0].work.id` from that submit output.
- The title is the film's name in the user's language — the title they gave, otherwise a short one you coin. Never a prompt opening, a duration ("15 seconds…"), an `@` mention, a file name or an id.
- Every later `generate video` for this film — a re-render or repair with `--target-work`, or a re-submit after a failed run — repeats the same `--work-title`. Without it the platform retitles the Work with the prompt's first words.
- **Only a `generate video` submit makes a video Work.** There is no import for a local video. A clip cut, stitched or retitled with ffmpeg is never the deliverable — not as a world file, not copied to `/public`, not as a public link. Don't hand-write work or artifact JSON to register one either.
- **Fit the film into one generation.** Read the model's max `duration` from `generate video params` and size the script table to it. Skip the playbook's multi-segment assembly. If the user asks for more than one take can hold, say so in the package ("one take holds 15 s, so the film is 15 s") and fit the beats to that.
- "Use what exists" / "just use the existing ones" as an answer to the one question means build from the world's existing cards, covers and images as references. It accepts your pick and is the go-ahead, like a bare approval above: show the package and submit a new `generate video` in that turn. Older video Works already in the world are not this film. Don't hand one over instead of shooting.
- "Don't redo or change the existing works" ("别重做或改动原来的作品") is not a refusal to generate. A new `generate video` makes a new Work and leaves every old Work untouched, so it still means shoot. Reuse existing covers and images as package references; generate only the missing ones as package material, and name in the package what was missing.
- Only if the user explicitly says not to generate a new video, and video Works already made for this ask exist, hand over those existing Works with work cards. Name plainly what is missing, such as a single combined cut. Don't assemble a new file.
- Pick the piece from the world's existing video Works that fit the ask. Prefer one ready Work that already holds the whole piece over separate shots. A video made for a different idea than the one picked does not fit. Embed each one and give its work card (`{ "type": "work", "workId": "<work_…>" }` via `interaction-components`) in that same reply. A bare `<video>` embed or CDN url is not a handover.
- Don't run ffmpeg, concat or re-encode, not even as a preview. Never link a local or world file. A missing combined cut is named, and offered as a new `generate video` with the package, never made by hand.
- If no existing video Work fits, say plainly that nothing has been delivered yet and offer to generate it.
## Check, then hand over
1. **Check.** When polling says the video is ready, run the check from the world root (`/workspace`). Use this skill's own directory as `<skill-dir>`: the one `skills use` printed, otherwise `.agents/skills/short-video`. The check is read-only and never opens the video:
```bash
node <skill-dir>/scripts/check_video.mjs <taskRunId> --work <workId> --duration <seconds from the script table>
```
It passes only when its last line is `SHORT_VIDEO_CHECK PASS` (the video is ready with a url, the duration matches, and the Work points at that video). On `FAIL`, fix what it names, or say the video is still generating. Never call the video done before a PASS.
2. **Hand over.** Embed the video, then hand over the Work through the `interaction-components` skill. Use a link card whose target is `{ "type": "work", "workId": "<outputs[0].work.id>" }`, with the Work's title as its name. That card is the handoff. Don't use a CDN url, a local file link or a downloaded copy instead.
- The playbook's Delivery section ends at the embed and a few sentences. This skill adds the card after them, in the same reply. A reply that embeds the video without the work card has not handed it over.
- The work card comes before any closing next-steps card. A next-steps options card never stands in for it, so a reply can carry both.
3. **If the turn ended while the video was still generating**, the next turn picks it up. Don't submit again. Poll `generate status` with the same `taskRunId`. Once it is ready, run the check above, then embed the video and send the work card. Re-submit only if the status says the run failed.
## Not this skill
- A first-person or close third-person slice-of-life moment → the `pov-life-slice` skill (neta-skills).
- A still image → use `generate` directly.