tk8544-b

---
name: animated-video-creator
version: "1.0.0"
displayName: "Animated Video Creator — Create Animated Videos from Text"
description: >
  marketers, small business owners, content creators create text or images into animated MP4 videos using this skill. Accepts PNG, JPG, MP4, GIF up to 200MB, renders on cloud GPUs at 1080p, and returns MP4 files in 1-2 minutes. Designed for creating animated explainer or promo videos from text and images.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Ready when you are. Drop your text or images here or describe what you want to make.

**Try saying:**
- "create a short script and three product images into a 1080p MP4"
- "turn my product description into a 30-second animated explainer video"
- "creating animated explainer or promo videos from text and images for marketers, small business owners, content creators"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Animated Video Creator — Create Animated Videos from Text

This tool takes your text or images and runs AI animation generation through a cloud rendering pipeline. You upload, describe what you want, and download the result.

Say you have a short script and three product images and want to turn my product description into a 30-second animated explainer video — the backend processes it in about 1-2 minutes and hands you a 1080p MP4.

Tip: shorter scripts under 60 seconds produce the most coherent animations.

## Matching Input to Actions

User prompts referencing animated video creator, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `animated-video-creator`, `X-Skill-Version` comes from the `version` field, and `X-Skill-Platform` is detected from the install path (`~/.clawhub/` = `clawhub`, `~/.cursor/skills/` = `cursor`, otherwise `unknown`).

Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "turn my product description into a 30-second animated explainer video" — concrete instructions get better results.

Max file size is 200MB. Stick to PNG, JPG, MP4, GIF for the smoothest experience.

Export as MP4 for widest compatibility across social platforms and presentations.

## Common Workflows

**Quick edit**: Upload → "turn my product description into a 30-second animated explainer video" → Download MP4. Takes 1-2 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

---
name: best-free-image-to-video-ai
version: "1.0.0"
displayName: "Best Free Image to Video AI — Convert Images Into Video Clips"
description: >
  social media creators convert still images into animated video clips using this skill. Accepts JPG, PNG, WEBP, HEIC up to 200MB, renders on cloud GPUs at 1080p, and returns MP4 files in 30-60 seconds. Designed for converting still photos into shareable videos.
metadata: {"openclaw": {"emoji": "🖼️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Share your still images and I'll get started on AI video creation. Or just tell me what you're thinking.

**Try saying:**
- "convert my still images"
- "export 1080p MP4"
- "turn my photos into a smooth"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Best Free Image to Video AI — Convert Images Into Video Clips

This tool takes your still images and runs AI video creation through a cloud rendering pipeline. You upload, describe what you want, and download the result.

Say you have three product photos or a single landscape image and want to turn my photos into a smooth animated video with transitions — the backend processes it in about 30-60 seconds and hands you a 1080p MP4.

Tip: using high-resolution images produces smoother motion output.

## Matching Input to Actions

User prompts referencing best free image to video ai, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `best-free-image-to-video-ai`, `X-Skill-Version` comes from the `version` field, and `X-Skill-Platform` is detected from the install path (`~/.clawhub/` = `clawhub`, `~/.cursor/skills/` = `cursor`, otherwise `unknown`).

Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "turn my photos into a smooth animated video with transitions" — concrete instructions get better results.

Max file size is 200MB. Stick to JPG, PNG, WEBP, HEIC for the smoothest experience.

Export as MP4 for widest compatibility.

## Common Workflows

**Quick edit**: Upload → "turn my photos into a smooth animated video with transitions" → Download MP4. Takes 30-60 seconds for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

---
name: animated-video-generator
version: "1.0.0"
displayName: "Animated Video Generator — Generate Animated Videos from Text"
description: >
  generate text or images into animated MP4 videos with this animated-video-generator skill. Works with PNG, JPG, MP4, GIF files up to 200MB. marketers, educators, content creators use it for creating animated explainer videos from text or images — processing takes 1-3 minutes on cloud GPUs and you get 1080p MP4 files.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Ready when you are. Drop your text or images here or describe what you want to make.

**Try saying:**
- "generate a short product description paragraph into a 1080p MP4"
- "turn this text into a 30-second animated explainer video with characters and motion graphics"
- "creating animated explainer videos from text or images for marketers, educators, content creators"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Animated Video Generator — Generate Animated Videos from Text

Send me your text or images and describe the result you want. The AI animation creation runs on remote GPU nodes — nothing to install on your machine.

A quick example: upload a short product description paragraph, type "turn this text into a 30-second animated explainer video with characters and motion graphics", and you'll get a 1080p MP4 back in roughly 1-3 minutes. All rendering happens server-side.

Worth noting: shorter scripts under 60 words produce tighter, faster animations.

## Matching Input to Actions

User prompts referencing animated video generator, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

All calls go to `https://mega-api-prod.nemovideo.ai`. The main endpoints:

1. **Session** — `POST /api/tasks/me/with-session/nemo_agent` with `{"task_name":"project","language":"<lang>"}`. Gives you a `session_id`.
2. **Chat (SSE)** — `POST /run_sse` with `session_id` and your message in `new_message.parts[0].text`. Set `Accept: text/event-stream`. Up to 15 min.
3. **Upload** — `POST /api/upload-video/nemo_agent/me/<sid>` — multipart file or JSON with URLs.
4. **Credits** — `GET /api/credits/balance/simple` — returns `available`, `frozen`, `total`.
5. **State** — `GET /api/state/nemo_agent/me/<sid>/latest` — current draft and media info.
6. **Export** — `POST /api/render/proxy/lambda` with render ID and draft JSON. Poll `GET /api/render/proxy/lambda/<id>` every 30s for `completed` status and download URL.

Formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `animated-video-generator`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Translating GUI Instructions

The backend responds as if there's a visual interface. Map its instructions to API calls:

- "click" or "点击" → execute the action via the relevant endpoint
- "open" or "打开" → query session state to get the data
- "drag/drop" or "拖拽" → send the edit command through SSE
- "preview in timeline" → show a text summary of current tracks
- "Export" or "导出" → run the export workflow

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "turn this text into a 30-second animated explainer video with characters and motion graphics" — concrete instructions get better results.

Max file size is 200MB. Stick to PNG, JPG, MP4, GIF for the smoothest experience.

Export as MP4 for widest compatibility across social and presentation platforms.

## Common Workflows

**Quick edit**: Upload → "turn this text into a 30-second animated explainer video with characters and motion graphics" → Download MP4. Takes 1-3 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

---
name: zen-creator
version: "1.0.0"
displayName: "Zen Creator — Create Calm Focused Videos"
description: >
  mindfulness creators create raw video footage into focused edited clips using this skill. Accepts MP4, MOV, AVI, WebM up to 500MB, renders on cloud GPUs at 1080p, and returns MP4 files in 1-2 minutes. Designed for creating calm minimal videos from raw footage.
metadata: {"openclaw": {"emoji": "🧘", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Share your raw video footage and I'll get started on AI calm editing. Or just tell me what you're thinking.

**Try saying:**
- "create my raw video footage"
- "export 1080p MP4"
- "remove background noise, add smooth transitions,"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Zen Creator — Create Calm Focused Videos

Drop your raw video footage in the chat and tell me what you need. I'll handle the AI calm editing on cloud GPUs — you don't need anything installed locally.

Here's a typical use: you send a a 3-minute vlog recorded on a smartphone, ask for remove background noise, add smooth transitions, and keep only the calm focused moments, and about 1-2 minutes later you've got a MP4 file ready to download. The whole thing runs at 1080p by default.

One thing worth knowing — shorter clips under 2 minutes process noticeably faster and keep the zen feel intact.

## Matching Input to Actions

User prompts referencing zen creator, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

All calls go to `https://mega-api-prod.nemovideo.ai`. The main endpoints:

1. **Session** — `POST /api/tasks/me/with-session/nemo_agent` with `{"task_name":"project","language":"<lang>"}`. Gives you a `session_id`.
2. **Chat (SSE)** — `POST /run_sse` with `session_id` and your message in `new_message.parts[0].text`. Set `Accept: text/event-stream`. Up to 15 min.
3. **Upload** — `POST /api/upload-video/nemo_agent/me/<sid>` — multipart file or JSON with URLs.
4. **Credits** — `GET /api/credits/balance/simple` — returns `available`, `frozen`, `total`.
5. **State** — `GET /api/state/nemo_agent/me/<sid>/latest` — current draft and media info.
6. **Export** — `POST /api/render/proxy/lambda` with render ID and draft JSON. Poll `GET /api/render/proxy/lambda/<id>` every 30s for `completed` status and download URL.

Formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Three attribution headers are required on every request and must match this file's frontmatter:

| Header | Value |
|--------|-------|
| `X-Skill-Source` | `zen-creator` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |

Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "remove background noise, add smooth transitions, and keep only the calm focused moments" — concrete instructions get better results.

Max file size is 500MB. Stick to MP4, MOV, AVI, WebM for the smoothest experience.

Export as MP4 for widest compatibility across YouTube, Instagram, and meditation platforms.

## Common Workflows

**Quick edit**: Upload → "remove background noise, add smooth transitions, and keep only the calm focused moments" → Download MP4. Takes 1-2 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

---
name: sora-ai-video-creator
version: "1.0.0"
displayName: "Sora AI Video Creator — Generate Videos from Text Prompts"
description: >
  Cloud-based sora-ai-video-creator tool that handles generating videos from text descriptions. Upload MP4, MOV, WebM, GIF files (up to 500MB), describe what you need, and get 1080p MP4 output in 1-3 minutes. Built for content creators who work with text prompts.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Share your text prompts and I'll get started on AI video generation. Or just tell me what you're thinking.

**Try saying:**
- "generate my text prompts"
- "export 1080p MP4"
- "generate a 10-second video of a"

### First-Time Connection

When a user first opens this skill, connect to the processing backend automatically. Briefly let them know (e.g. "Setting up...").

**Authentication**: Check if `NEMO_TOKEN` is set in the environment. If it is, skip to step 2.

1. **Obtain a free token**: Generate a random UUID as client identifier. POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id` set to that UUID. The response `data.token` is your NEMO_TOKEN — 100 free credits, valid 7 days.
2. **Create a session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with `Authorization: Bearer <token>`, `Content-Type: application/json`, and body `{"task_name":"project","language":"<detected>"}`. Store the returned `session_id` for all subsequent requests.

Keep setup communication brief. Don't display raw API responses or token values to the user.

# Sora AI Video Creator — Generate Videos from Text Prompts

Send me your text prompts and describe the result you want. The AI video generation runs on remote GPU nodes — nothing to install on your machine.

A quick example: upload a short text description of a scene, type "generate a 10-second video of a sunset over the ocean with cinematic camera movement", and you'll get a 1080p MP4 back in roughly 1-3 minutes. All rendering happens server-side.

Worth noting: shorter, more specific prompts tend to produce more accurate and consistent results.

## Matching Input to Actions

User prompts referencing sora ai video creator, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

All calls go to `https://mega-api-prod.nemovideo.ai`. The main endpoints:

1. **Session** — `POST /api/tasks/me/with-session/nemo_agent` with `{"task_name":"project","language":"<lang>"}`. Gives you a `session_id`.
2. **Chat (SSE)** — `POST /run_sse` with `session_id` and your message in `new_message.parts[0].text`. Set `Accept: text/event-stream`. Up to 15 min.
3. **Upload** — `POST /api/upload-video/nemo_agent/me/<sid>` — multipart file or JSON with URLs.
4. **Credits** — `GET /api/credits/balance/simple` — returns `available`, `frozen`, `total`.
5. **State** — `GET /api/state/nemo_agent/me/<sid>/latest` — current draft and media info.
6. **Export** — `POST /api/render/proxy/lambda` with render ID and draft JSON. Poll `GET /api/render/proxy/lambda/<id>` every 30s for `completed` status and download URL.

Formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Three attribution headers are required on every request and must match this file's frontmatter:

| Header | Value |
|--------|-------|
| `X-Skill-Source` | `sora-ai-video-creator` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |

Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Translating GUI Instructions

The backend responds as if there's a visual interface. Map its instructions to API calls:

- "click" or "点击" → execute the action via the relevant endpoint
- "open" or "打开" → query session state to get the data
- "drag/drop" or "拖拽" → send the edit command through SSE
- "preview in timeline" → show a text summary of current tracks
- "Export" or "导出" → run the export workflow

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Common Workflows

**Quick edit**: Upload → "generate a 10-second video of a sunset over the ocean with cinematic camera movement" → Download MP4. Takes 1-3 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "generate a 10-second video of a sunset over the ocean with cinematic camera movement" — concrete instructions get better results.

Max file size is 500MB. Stick to MP4, MOV, WebM, GIF for the smoothest experience.

Export as MP4 for widest compatibility across social platforms and editors.

---
name: text-to-image-ai-free
version: "1.0.0"
displayName: "Text to Image AI Free — Generate Images from Text Prompts"
description: >
  content creators generate text prompts into AI generated visuals using this skill. Accepts JPG, PNG, WEBP, MP4 up to 200MB, renders on cloud GPUs at 1080p, and returns MP4 files in 20-40 seconds. Designed for generating images from text descriptions for video content.
metadata: {"openclaw": {"emoji": "🖼️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me your text prompts and I'll handle the AI image generation. Or just describe what you're after.

**Try saying:**
- "generate a short descriptive text prompt like 'sunset over a mountain lake' into a 1080p MP4"
- "generate a realistic image of a futuristic city at night with neon lights"
- "generating images from text descriptions for video content for content creators"

### Quick Start Setup

This skill connects to a cloud processing backend. On first use, set up the connection automatically and let the user know ("Connecting...").

**Token check**: Look for `NEMO_TOKEN` in the environment. If found, skip to session creation. Otherwise:
- Generate a UUID as client identifier
- POST `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with `X-Client-Id` header
- Extract `data.token` from the response — this is your NEMO_TOKEN (100 free credits, 7-day expiry)

**Session**: POST `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Keep the returned `session_id` for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

# Text to Image AI Free — Generate Images from Text Prompts

Drop your text prompts in the chat and tell me what you need. I'll handle the AI image generation on cloud GPUs — you don't need anything installed locally.

Here's a typical use: you send a a short descriptive text prompt like 'sunset over a mountain lake', ask for generate a realistic image of a futuristic city at night with neon lights, and about 20-40 seconds later you've got a MP4 file ready to download. The whole thing runs at 1080p by default.

One thing worth knowing — shorter, specific prompts tend to produce more accurate and usable images.

## Matching Input to Actions

User prompts referencing text to image ai free, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

Base URL: `https://mega-api-prod.nemovideo.ai`

| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/api/tasks/me/with-session/nemo_agent` | POST | Start a new editing session. Body: `{"task_name":"project","language":"<lang>"}`. Returns `session_id`. |
| `/run_sse` | POST | Send a user message. Body includes `app_name`, `session_id`, `new_message`. Stream response with `Accept: text/event-stream`. Timeout: 15 min. |
| `/api/upload-video/nemo_agent/me/<sid>` | POST | Upload a file (multipart) or URL. |
| `/api/credits/balance/simple` | GET | Check remaining credits (`available`, `frozen`, `total`). |
| `/api/state/nemo_agent/me/<sid>/latest` | GET | Fetch current timeline state (`draft`, `video_infos`, `generated_media`). |
| `/api/render/proxy/lambda` | POST | Start export. Body: `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll status every 30s. |

Accepted file types: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `text-to-image-ai-free`, `X-Skill-Version` comes from the `version` field, and `X-Skill-Platform` is detected from the install path (`~/.clawhub/` = `clawhub`, `~/.cursor/skills/` = `cursor`, otherwise `unknown`).

Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "generate a realistic image of a futuristic city at night with neon lights" — concrete instructions get better results.

Max file size is 200MB. Stick to JPG, PNG, WEBP, MP4 for the smoothest experience.

Export as MP4 for widest compatibility when embedding images into video sequences.

## Common Workflows

**Quick edit**: Upload → "generate a realistic image of a futuristic city at night with neon lights" → Download MP4. Takes 20-40 seconds for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

---
name: video-ai
version: "1.0.0"
displayName: "Video AI — Edit and Export AI Videos"
description: >
  content creators and marketers edit raw video footage into AI-edited videos using this skill. Accepts MP4, MOV, AVI, WebM up to 500MB, renders on cloud GPUs at 1080p, and returns MP4 files in 1-2 minutes. Designed for automatically editing and enhancing raw video recordings.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Got raw video footage to work with? Send it over and tell me what you need — I'll take care of the AI video editing.

**Try saying:**
- "edit a 2-minute unedited screen recording into a 1080p MP4"
- "cut the silences, add captions, and export as a clean MP4"
- "automatically editing and enhancing raw video recordings for content creators and marketers"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Video AI — Edit and Export AI Videos

Send me your raw video footage and describe the result you want. The AI video editing runs on remote GPU nodes — nothing to install on your machine.

A quick example: upload a 2-minute unedited screen recording, type "cut the silences, add captions, and export as a clean MP4", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.

Worth noting: shorter clips under 60 seconds process significantly faster.

## Matching Input to Actions

User prompts referencing video ai, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

Three attribution headers are required on every request and must match this file's frontmatter:

| Header | Value |
|--------|-------|
| `X-Skill-Source` | `video-ai` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |

Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

## Common Workflows

**Quick edit**: Upload → "cut the silences, add captions, and export as a clean MP4" → Download MP4. Takes 1-2 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "cut the silences, add captions, and export as a clean MP4" — concrete instructions get better results.

Max file size is 500MB. Stick to MP4, MOV, AVI, WebM for the smoothest experience.

Export as MP4 for widest compatibility across platforms.

---
name: best-avatar-video
version: "1.0.0"
displayName: "Best Avatar Video — Generate Talking Avatar Videos"
description: >
  Cloud-based best-avatar-video tool that handles creating realistic talking avatar videos from photos and scripts. Upload JPG, PNG, MP4, MOV files (up to 200MB), describe what you need, and get 1080p MP4 output in 1-2 minutes. Built for marketers, educators, content creators who work with text or images.
metadata: {"openclaw": {"emoji": "🧑‍💻", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Got text or images to work with? Send it over and tell me what you need — I'll take care of the AI avatar video creation.

**Try saying:**
- "generate a headshot photo and a 200-word script into a 1080p MP4"
- "create a talking avatar video from my photo and script in English"
- "creating realistic talking avatar videos from photos and scripts for marketers, educators, content creators"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Best Avatar Video — Generate Talking Avatar Videos

Send me your text or images and describe the result you want. The AI avatar video creation runs on remote GPU nodes — nothing to install on your machine.

A quick example: upload a headshot photo and a 200-word script, type "create a talking avatar video from my photo and script in English", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.

Worth noting: shorter scripts under 60 seconds render noticeably faster.

## Matching Input to Actions

User prompts referencing best avatar video, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

Base URL: `https://mega-api-prod.nemovideo.ai`

| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/api/tasks/me/with-session/nemo_agent` | POST | Start a new editing session. Body: `{"task_name":"project","language":"<lang>"}`. Returns `session_id`. |
| `/run_sse` | POST | Send a user message. Body includes `app_name`, `session_id`, `new_message`. Stream response with `Accept: text/event-stream`. Timeout: 15 min. |
| `/api/upload-video/nemo_agent/me/<sid>` | POST | Upload a file (multipart) or URL. |
| `/api/credits/balance/simple` | GET | Check remaining credits (`available`, `frozen`, `total`). |
| `/api/state/nemo_agent/me/<sid>/latest` | GET | Fetch current timeline state (`draft`, `video_infos`, `generated_media`). |
| `/api/render/proxy/lambda` | POST | Start export. Body: `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll status every 30s. |

Accepted file types: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `best-avatar-video`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

## Common Workflows

**Quick edit**: Upload → "create a talking avatar video from my photo and script in English" → Download MP4. Takes 1-2 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "create a talking avatar video from my photo and script in English" — concrete instructions get better results.

Max file size is 200MB. Stick to JPG, PNG, MP4, MOV for the smoothest experience.

Export as MP4 for widest compatibility across social and presentation platforms.

---
name: easy-ai-video-editor
version: "1.0.0"
displayName: "Easy AI Video Editor — Edit and Export Polished Videos"
description: >
  casual creators and social media users edit raw video footage into polished edited clips using this skill. Accepts MP4, MOV, AVI, WebM up to 500MB, renders on cloud GPUs at 1080p, and returns MP4 files in 1-2 minutes. Designed for quickly editing raw footage into a shareable video without manual timeline work.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Got raw video footage to work with? Send it over and tell me what you need — I'll take care of the AI video editing.

**Try saying:**
- "edit a 2-minute phone-recorded vlog clip into a 1080p MP4"
- "trim the pauses, add transitions, and put text overlays on key moments"
- "quickly editing raw footage into a shareable video without manual timeline work for casual creators and social media users"

### Quick Start Setup

This skill connects to a cloud processing backend. On first use, set up the connection automatically and let the user know ("Connecting...").

**Token check**: Look for `NEMO_TOKEN` in the environment. If found, skip to session creation. Otherwise:
- Generate a UUID as client identifier
- POST `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with `X-Client-Id` header
- Extract `data.token` from the response — this is your NEMO_TOKEN (100 free credits, 7-day expiry)

**Session**: POST `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Keep the returned `session_id` for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

# Easy AI Video Editor — Edit and Export Polished Videos

Drop your raw video footage in the chat and tell me what you need. I'll handle the AI video editing on cloud GPUs — you don't need anything installed locally.

Here's a typical use: you send a a 2-minute phone-recorded vlog clip, ask for trim the pauses, add transitions, and put text overlays on key moments, and about 1-2 minutes later you've got a MP4 file ready to download. The whole thing runs at 1080p by default.

One thing worth knowing — shorter clips under 60 seconds process noticeably faster and give cleaner AI results.

## Matching Input to Actions

User prompts referencing easy ai video editor, aspect ratio, text overlays, or audio tracks get routed to the corresponding action via keyword and intent classification.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Render Pipeline Details

Each export job queues on a cloud GPU node that composites video layers, applies platform-spec compression (H.264, up to 1080x1920), and returns a download URL within 30-90 seconds. The session token carries render job IDs, so closing the tab before completion orphans the job.

All calls go to `https://mega-api-prod.nemovideo.ai`. The main endpoints:

1. **Session** — `POST /api/tasks/me/with-session/nemo_agent` with `{"task_name":"project","language":"<lang>"}`. Gives you a `session_id`.
2. **Chat (SSE)** — `POST /run_sse` with `session_id` and your message in `new_message.parts[0].text`. Set `Accept: text/event-stream`. Up to 15 min.
3. **Upload** — `POST /api/upload-video/nemo_agent/me/<sid>` — multipart file or JSON with URLs.
4. **Credits** — `GET /api/credits/balance/simple` — returns `available`, `frozen`, `total`.
5. **State** — `GET /api/state/nemo_agent/me/<sid>/latest` — current draft and media info.
6. **Export** — `POST /api/render/proxy/lambda` with render ID and draft JSON. Poll `GET /api/render/proxy/lambda/<id>` every 30s for `completed` status and download URL.

Formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `easy-ai-video-editor`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Translating GUI Instructions

The backend responds as if there's a visual interface. Map its instructions to API calls:

- "click" or "点击" → execute the action via the relevant endpoint
- "open" or "打开" → query session state to get the data
- "drag/drop" or "拖拽" → send the edit command through SSE
- "preview in timeline" → show a text summary of current tracks
- "Export" or "导出" → run the export workflow

### Reading the SSE Stream

Text events go straight to the user (after GUI translation). Tool calls stay internal. Heartbeats and empty `data:` lines mean the backend is still working — show "⏳ Still working..." every 2 minutes.

About 30% of edit operations close the stream without any text. When that happens, poll `/api/state` to confirm the timeline changed, then tell the user what was updated.

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

## Common Workflows

**Quick edit**: Upload → "trim the pauses, add transitions, and put text overlays on key moments" → Download MP4. Takes 1-2 minutes for a 30-second clip.

**Batch style**: Upload multiple files in one session. Process them one by one with different instructions. Each gets its own render.

**Iterative**: Start with a rough cut, preview the result, then refine. The session keeps your timeline state so you can keep tweaking.

## Tips and Tricks

The backend processes faster when you're specific. Instead of "make it look better", try "trim the pauses, add transitions, and put text overlays on key moments" — concrete instructions get better results.

Max file size is 500MB. Stick to MP4, MOV, AVI, WebM for the smoothest experience.

Export as MP4 for widest compatibility across platforms and devices.

---
name: bytedance-video-generator
version: "1.0.0"
displayName: "ByteDance Video Generator — Generate Videos from Text Prompts"
description: >
  generate text prompts or clips into AI-generated videos with this bytedance-video-generator skill. Works with MP4, MOV, WebM, GIF files up to 500MB. TikTok creators use it for generating short videos from text prompts or images — processing takes 1-2 minutes on cloud GPUs and you get 1080p MP4 files.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Drop your text prompts or clips here and tell me what to do with it. Describe your idea if you don't have files yet.

**Try saying:**
- "generate a short text description of a product scene into a 1080p MP4"
- "generate a 15-second video clip from this text prompt about a city at sunset"
- "generating short videos from text prompts or images for TikTok creators"

### Quick Start Setup

This skill connects to a cloud processing backend. On first use, set up the connection automatically and let the user know ("Connecting...").

**Token check**: Look for `NEMO_TOKEN` in the environment. If found, skip to session creation. Otherwise:
- Generate a UUID as client identifier
- POST `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with `X-Client-Id` header
- Extract `data.token` from the response — this is your NEMO_TOKEN (100 free credits, 7-day expiry)

**Session**: POST `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Keep the returned `session_id` for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

# Bytedance Video Generator — What You Get

What does this do? It takes your text prompts or clips and runs AI video generation on a cloud backend. Nothing to install.

Real example: I threw in a short text description of a product scene, typed "generate a 15-second video clip from this text prompt about a city at sunset", and 1-2 minutes later had a clean MP4 file. Default output is 1080p.

Quick note: shorter and more specific prompts tend to produce more accurate video output.

## Request Routing

Your request is matched to one of several actions depending on what you typed.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Technical Details

Processing runs on remote GPUs through NemoVideo's API. The skill sends your input, waits for the render, and hands back the result — all server-side.

Base URL: `https://mega-api-prod.nemovideo.ai`

| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/api/tasks/me/with-session/nemo_agent` | POST | Start a new editing session. Body: `{"task_name":"project","language":"<lang>"}`. Returns `session_id`. |
| `/run_sse` | POST | Send a user message. Body includes `app_name`, `session_id`, `new_message`. Stream response with `Accept: text/event-stream`. Timeout: 15 min. |
| `/api/upload-video/nemo_agent/me/<sid>` | POST | Upload a file (multipart) or URL. |
| `/api/credits/balance/simple` | GET | Check remaining credits (`available`, `frozen`, `total`). |
| `/api/state/nemo_agent/me/<sid>/latest` | GET | Fetch current timeline state (`draft`, `video_infos`, `generated_media`). |
| `/api/render/proxy/lambda` | POST | Start export. Body: `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll status every 30s. |

Accepted file types: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Three attribution headers are required on every request and must match this file's frontmatter:

| Header | Value |
|--------|-------|
| `X-Skill-Source` | `bytedance-video-generator` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |

Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

## Quick Start Guide

First time? Just upload a text prompts or clips and describe what you need. I'll run it through NemoVideo's backend and hand you back a 1080p MP4.

Processing takes about 1-2 minutes depending on video length. You start with 100 free credits — most edits cost 1-3.

## Tips and Tricks

Keep your source files under 500MB for fastest processing. If you're working with longer content, split it into chunks first.

For best results at 1080p, make sure your input is at least 720p. Upscaling from 480p works but you'll notice it.

Export as MP4 for widest compatibility across social platforms.

---
name: seedance-vs-runway
version: "1.0.0"
displayName: "Seedance vs Runway — AI Video Generator Comparison for Creators"
description: >
  Get a side-by-side breakdown of Seedance vs Runway so you know exactly which AI video generator fits your project before you spend a dollar. This skill covers the Seedance versus Runway debate across output resolution, generation speed, and credit costs — real numbers, not marketing copy. Built for YouTubers, short-form creators, and marketers who need to pick the right text-to-video or image-to-video tool and export a clean MP4 without guessing.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "control"}}
---

## Getting Started

> I compare Seedance vs Runway head-to-head so you stop burning credits on the wrong platform. Tell me what kind of video you're trying to make and I'll point you straight to the right tool.

**Try saying:**
- "Seedance vs Runway for generating 4K cinematic B-roll from a still image"
- "which is better for TikTok ads Seedance or Runway Gen-3"
- "compare Seedance and Runway credit costs for 30 short clips"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Pick the Right AI Video Tool Before You Waste Credits

Say you want to generate a 5-second clip from a single image. Seedance handles that in roughly 20–40 seconds depending on the motion preset you pick, while Runway Gen-3 Alpha takes closer to 60–90 seconds for a comparable 720p output. That time gap adds up fast if you're batching 30 clips for a product reel.

The credit math is different too. Runway charges per second of video generated, so a 10-second clip costs more than two 5-second ones stitched together. Seedance uses a flat generation cost regardless of duration up to its 5-second cap.

You tell this skill what you're making — a talking-head loop, a cinematic B-roll shot, a social ad — and it maps your use case to the tool that actually fits, with specific settings to plug in.

## Routing Seedance and Runway Requests

When you describe a generation task, the skill checks for keywords like 'motion brush' or 'camera control' to route you to Runway Gen-3, or 'pose consistency' and 'character lock' to route you to Seedance.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud GPU Processing Details

Runway offloads inference to its own A100 GPU clusters and returns an MP4 via a signed CDN URL, typically within 30–90 seconds for a 5-second clip. Seedance queues jobs on ByteDance's cloud infrastructure and streams progress tokens back before delivering the final video file.

Base URL: `https://mega-api-prod.nemovideo.ai`

| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/api/tasks/me/with-session/nemo_agent` | POST | Start a new editing session. Body: `{"task_name":"project","language":"<lang>"}`. Returns `session_id`. |
| `/run_sse` | POST | Send a user message. Body includes `app_name`, `session_id`, `new_message`. Stream response with `Accept: text/event-stream`. Timeout: 15 min. |
| `/api/upload-video/nemo_agent/me/<sid>` | POST | Upload a file (multipart) or URL. |
| `/api/credits/balance/simple` | GET | Check remaining credits (`available`, `frozen`, `total`). |
| `/api/state/nemo_agent/me/<sid>/latest` | GET | Fetch current timeline state (`draft`, `video_infos`, `generated_media`). |
| `/api/render/proxy/lambda` | POST | Start export. Body: `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll status every 30s. |

Accepted file types: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `seedance-vs-runway`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.

### Error Codes

- `0` — success, continue normally
- `1001` — token expired or invalid; re-acquire via `/api/auth/anonymous-token`
- `1002` — session not found; create a new one
- `2001` — out of credits; anonymous users get a registration link with `?bind=<id>`, registered users top up
- `4001` — unsupported file type; show accepted formats
- `4002` — file too large; suggest compressing or trimming
- `400` — missing `X-Client-Id`; generate one and retry
- `402` — free plan export blocked; not a credit issue, subscription tier
- `429` — rate limited; wait 30s and retry once

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

Draft JSON uses short keys: `t` for tracks, `tt` for track type (0=video, 1=audio, 7=text), `sg` for segments, `d` for duration in ms, `m` for metadata.

Example timeline summary:
```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

## Performance Notes: Speed and Quality Benchmarks for Seedance vs Runway

In back-to-back tests generating a 5-second image-to-video clip, Seedance averaged 28 seconds per generation on standard queue, Runway averaged 74 seconds. That's nearly a 3x speed difference on identical prompts.

Quality is not a clean win for either side. Runway holds edge detail better — text on a sign stays readable at 1280×768, where Seedance at the same resolution softens it. But Seedance handles camera motion prompts more literally. Tell it 'slow push in' and you get a slow push in. Runway interprets motion prompts loosely about 40% of the time.

For file size, a 5-second Runway MP4 typically lands around 8–12 MB. Seedance outputs run 4–7 MB for the same duration. That gap matters if you're uploading 50 clips to a client folder or hitting a platform's 100 MB asset limit.

## Troubleshooting: When Your Seedance or Runway Output Looks Wrong

If your Seedance clip comes back blurry at 512×512 instead of the 1024×576 you expected, the motion intensity slider is usually the culprit — crank it past 7 and the model sacrifices spatial detail to hit the movement target. Drop it to 4 or 5 and re-run.

Runway Gen-3 has a different failure mode. It'll produce a perfectly sharp 1280×768 MP4 but the motion feels frozen for the first 12 frames. That's the model's warm-up lag, not a bug. Trim those frames in your editor before you export.

Both platforms time out on slow connections. Seedance cuts the job at 3 minutes server-side, Runway at 5. If you're on a shared office network and generations keep failing, switch to a mobile hotspot and retry — that alone fixes roughly 60% of timeout errors people blame on the tools.

---
name: pixbim-lip-sync-ai
version: "1.0.0"
displayName: "Pixbim Lip Sync AI — Automatically Sync Lips to Any Audio Track"
description: >
  Turn any video into a perfectly lip-synced production using pixbim-lip-sync-ai — the tool that matches mouth movements to dialogue, dubbing, or voiceover with frame-level precision. Whether you're localizing content for new markets, fixing out-of-sync audio, or animating a character's speech, this skill helps you generate accurate lip sync results without manual keyframing or rotoscoping. Built for content creators, filmmakers, and localization teams.
metadata: {"openclaw": {"emoji": "🎤", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "control"}}
---

## Getting Started

> Welcome to Pixbim Lip Sync AI — your shortcut to perfectly synchronized lips and audio in any video. Share your video details or audio track and let's get your lip sync dialed in right now.

**Try saying:**
- "I have a Spanish dubbed audio track and an English video — can you help me sync the lip movements to the Spanish dialogue using Pixbim Lip Sync AI?"
- "My interview footage has audio that drifted out of sync halfway through the recording. How do I use Pixbim Lip Sync AI to fix the mouth movement alignment?"
- "I'm working on an animated character and I want to use Pixbim Lip Sync AI to match the mouth shapes to a recorded voiceover line — what's the best approach?"

### First-Time Connection

When a user first opens this skill, connect to the processing backend automatically. Briefly let them know (e.g. "Setting up...").

**Authentication**: Check if `NEMO_TOKEN` is set in the environment. If it is, skip to step 2.

1. **Obtain a free token**: Generate a random UUID as client identifier. POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id` set to that UUID. The response `data.token` is your NEMO_TOKEN — 100 free credits, valid 7 days.
2. **Create a session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with `Authorization: Bearer <token>`, `Content-Type: application/json`, and body `{"task_name":"project","language":"<detected>"}`. Store the returned `session_id` for all subsequent requests.

Keep setup communication brief. Don't display raw API responses or token values to the user.

# Make Every Word Match Every Mouth Movement

Lip sync errors are one of the most distracting problems in video production — whether you're dubbing a film into a new language, adding a voiceover to an animated character, or correcting audio drift in a recorded interview. Pixbim Lip Sync AI solves this by analyzing both the audio track and the facial movements in your video, then intelligently aligning them so every syllable lands exactly when the lips move.

This skill gives you direct access to Pixbim's lip sync engine through a conversational interface. You can describe your project, specify your source video and target audio, and get back a synchronized output without needing to touch a timeline or manually adjust keyframes. It's designed for workflows where speed and accuracy both matter.

Content creators producing multilingual versions of their videos, game developers animating NPC dialogue, and post-production teams cleaning up dubbing artifacts will all find this tool cuts hours of manual work down to minutes. The result is natural-looking mouth movement that holds up under scrutiny — not the rubbery, approximate sync you get from generic tools.

## Routing Lip Sync Requests

When you submit a lip sync job, your request is parsed for the target video clip, audio track, and facial detection parameters, then dispatched to the appropriate Pixbim processing pipeline based on resolution tier and sync mode selected.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Pixbim API Backend Reference

Pixbim Lip Sync AI runs on a cloud-based neural rendering backend that performs per-frame phoneme mapping and mouth-shape blending using its trained deep learning model. All video assets are temporarily staged in secure cloud storage during the synthesis pass, then returned as a processed output file once the lip sync render is finalized.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `pixbim-lip-sync-ai`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide

Pixbim Lip Sync AI works by taking a source video containing a face or character and a separate audio track, then processing both to generate a synchronized output. To get the best results, your video should have a clearly visible face or mouth region with consistent lighting — heavy motion blur or extreme camera angles can reduce sync accuracy.

When submitting a project through this skill, provide the video resolution, frame rate, and whether the subject is a live-action person or a 2D/3D animated character. Pixbim handles both, but the processing pipeline differs. For dubbing workflows, supply the target language audio as a clean WAV or MP3 file, and specify whether you want the original background audio preserved beneath the new dialogue.

For batch localization — syncing the same video to multiple language tracks — describe all target audio files in a single request and the skill will structure the job accordingly. Output files are delivered in the same format and resolution as your source video unless you specify otherwise.

## Troubleshooting

If your lip sync output looks off, the most common cause is a mismatch between the audio sample rate and the video frame rate. Make sure your audio file is exported at 44.1kHz or 48kHz and your video is a standard frame rate (24, 25, or 30fps) before submitting. Non-standard frame rates can cause Pixbim Lip Sync AI to miscalculate the timing offsets.

For animated characters, if the mouth shapes appear generic or don't match the phonemes in the audio, check whether the character rig supports viseme-based animation. Pixbim Lip Sync AI outputs viseme data that requires a compatible rig — if your character only has basic open/close mouth states, the sync will appear simplified.

If the face is not being detected in the source video, ensure the subject's face occupies at least 15% of the frame and is not obscured by masks, heavy makeup, or extreme lighting. Submitting a short test clip first is a good way to confirm detection before processing a full-length video.

---
name: best-free-ai-video-generator
version: "1.0.0"
displayName: "Best Free AI Video Generator — Create Stunning Videos From Text or Images"
description: >
  Describe your idea, drop some images, or paste a script — and watch it become a fully produced video in seconds. This best-free-ai-video-generator skill helps creators, marketers, and educators turn raw concepts into polished video content without spending a dime. Generate text-to-video clips, animate still photos, add voiceovers, and produce social-ready formats across platforms like TikTok, YouTube, and Instagram.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me your script, image, or video idea and I'll generate a polished AI video for you right now. No footage? Just describe the vibe, topic, or story you want and I'll handle the rest.

**Try saying:**
- "Create a 30-second promotional video for my handmade candle business using these product photos and this tagline: 'Light your world, naturally.'"
- "Generate a motivational YouTube Short with bold captions, upbeat background music, and a voiceover based on this quote about perseverance."
- "Turn this 200-word blog post about healthy meal prep into an engaging Instagram Reel with text overlays and smooth transitions."

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Turn Any Idea Into a Finished Video Instantly

Whether you have a script, a single sentence, or just a rough concept, this skill transforms your input into watchable, shareable video content — no timeline editing, no expensive subscriptions, no steep learning curve required. It's built for people who need results fast and budgets that need to stay at zero.

The best-free-ai-video-generator skill works by understanding your intent and matching it with the right visual style, pacing, and structure. Want a 60-second product explainer? A motivational reel with captions? A slideshow with dynamic transitions and background music? Just describe it and the skill handles the creative heavy lifting.

This tool is especially useful for solo creators, small business owners, nonprofit teams, and students who need professional-looking video output without access to a design team or video production software. You bring the idea — this skill brings it to life.

## Routing Your Video Generation Requests

When you submit a text prompt or source image, ClawHub parses your input and routes it to the optimal free AI video generation engine based on your requested style, duration, and resolution parameters.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering API Reference

Video synthesis runs on a distributed cloud backend that queues your text-to-video or image-to-video job, applies diffusion-based frame generation, and streams the rendered MP4 output back once processing completes. Latency varies by model load, clip length, and selected frame rate — lightweight 3-second clips typically render faster than extended 10-second sequences.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `best-free-ai-video-generator`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Common Workflows With the Free AI Video Generator

Most users come to this skill with one of three starting points: a written script, a collection of images, or just a topic idea. Each path leads to a finished video, but the workflow looks a little different depending on what you bring.

If you have a script, paste it in and specify the target platform and length. The skill will match your words to visuals, add transitions, and suggest audio options. If you're starting from images, upload them in order or describe the sequence and the skill will animate, time, and style them into a cohesive clip.

For pure concept-to-video generation — where you only have a topic — describe the tone, audience, and goal. The skill will draft a visual storyboard, generate or source matching visuals, and produce a ready-to-export video. This workflow is especially popular for explainer videos, social content calendars, and educational clips.

## Quick Start Guide: Your First AI-Generated Video

Getting your first video out is straightforward. Start by deciding your output format: horizontal (16:9) for YouTube, vertical (9:16) for TikTok or Reels, or square (1:1) for general social use. Mention this upfront so the layout is optimized from the start.

Next, provide your core content. This can be a script (even bullet points work), a theme or topic, or a set of images with captions. The more specific you are about tone — cinematic, energetic, calm, corporate — the closer the first output will be to what you want.

Finally, specify any must-have elements: voiceover language, caption style, music mood, or brand colors. The skill will generate a draft video based on your inputs. You can then request adjustments like trimming a section, changing the pacing, swapping a visual, or updating the text overlay. Most users have a shareable video ready within two to three rounds of feedback.

## Troubleshooting Your AI Video Output

If your generated video feels off, the most common fix is adding more context to your original prompt. Vague inputs like 'make a cool video' produce generic results. Try specifying the audience, the emotion you want to trigger, the platform it's for, and the length.

If the visuals don't match your brand or topic, try describing the visual style more explicitly — for example, 'minimalist white background with bold sans-serif text' or 'warm golden-hour outdoor footage.' You can also upload reference images to anchor the aesthetic.

For voiceover issues, confirm the language, accent preference, and speaking pace in your request. If captions are appearing in the wrong position or font, describe your preferred style directly. And if the video feels too long or too fast, simply ask for a tighter cut or a slower pace — the skill can revise timing without regenerating the entire video from scratch.

---
name: image-to-video-ai-generator-free
version: "1.0.0"
displayName: "Image to Video AI Generator Free — Animate Still Photos into Dynamic Videos"
description: >
  Tell me what you need and I'll help you turn static images into captivating videos without spending a dime. This image-to-video-ai-generator-free skill walks you through the fastest free tools, prompt strategies, and workflows to animate photos, create slideshows with motion effects, or produce cinematic clips from a single still. Whether you're a content creator, small business owner, or social media enthusiast, get frame-by-frame guidance tailored to your project.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Drop your image or describe your photo and I'll tell you exactly which free AI tool to use and what prompt to write to generate a compelling video from it. No image yet? Just describe the scene and I'll guide you from scratch.

**Try saying:**
- "I have a product photo of a sneaker on a white background — what's the best free AI tool to animate it with subtle motion for an Instagram ad?"
- "I want to turn 10 vacation photos into a 30-second video with smooth transitions and background music using only free tools. How do I do that?"
- "I uploaded my portrait to Runway but the motion looks unnatural and glitchy — what prompt changes or settings should I try to fix it?"

### First-Time Connection

When a user first opens this skill, connect to the processing backend automatically. Briefly let them know (e.g. "Setting up...").

**Authentication**: Check if `NEMO_TOKEN` is set in the environment. If it is, skip to step 2.

1. **Obtain a free token**: Generate a random UUID as client identifier. POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id` set to that UUID. The response `data.token` is your NEMO_TOKEN — 100 free credits, valid 7 days.
2. **Create a session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with `Authorization: Bearer <token>`, `Content-Type: application/json`, and body `{"task_name":"project","language":"<detected>"}`. Store the returned `session_id` for all subsequent requests.

Keep setup communication brief. Don't display raw API responses or token values to the user.

# From Still Photo to Moving Story — For Free

Most people assume turning an image into a video requires expensive software or a professional editor. That assumption is outdated. A new wave of free AI tools can take a single photograph — a portrait, a product shot, a landscape — and breathe life into it with realistic motion, cinematic panning, or stylized animation.

This skill is your hands-on guide through that process. Instead of wading through tutorials scattered across the internet, you get a focused assistant that helps you choose the right free platform for your specific image type, craft the text prompts that produce the best motion results, and troubleshoot when outputs don't look the way you imagined.

Whether you want a looping background video for your website, an animated post for Instagram Reels, or a short cinematic clip from a family photo, this skill covers the full journey — from uploading your image to exporting a shareable video file — using only tools that cost nothing to start.

## Routing Animate Requests Intelligently

When you submit a still photo for animation, ClawHub parses your motion prompt, frame rate preference, and output duration to route your request to the optimal image-to-video inference pipeline.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering API Reference

The free image-to-video backend leverages diffusion-based temporal synthesis models hosted on distributed GPU clusters, converting static frames into fluid motion sequences without local processing overhead. Each API call passes your source image alongside motion vectors and interpolation parameters to generate smooth keyframe transitions in the cloud.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `image-to-video-ai-generator-free`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide

Getting started with free image-to-video AI tools is straightforward once you know which platforms accept direct image uploads versus those that work from text prompts alone. Tools like Runway Gen-2, Kling AI (free tier), and Pika Labs all accept still images as a starting point and offer free credits or a freemium model to generate short video clips.

For workflow integration, you can export the generated video as an MP4 and drop it directly into tools like CapCut, DaVinci Resolve (free), or Canva to add text overlays, music, or color grading. If you're building a content pipeline, pairing an image-to-video generator with a free scheduler like Buffer lets you automate posting animated content to social platforms.

Always check resolution limits on free tiers — most cap exports at 720p. If you need 1080p, some tools offer a one-time free upscale or integrate with free upscalers like Topaz Gigapixel's trial version to boost quality before publishing.

## Common Workflows

The most popular workflow is the single-image cinematic pan: upload a wide landscape or architectural photo, write a prompt like 'slow dolly forward with gentle camera drift,' and export a 4-second loop. This works exceptionally well for website hero backgrounds and YouTube intro cards.

For e-commerce, a product-spin workflow is highly effective — upload a flat-lay product image, prompt the AI to rotate or zoom in gradually, and you get a dynamic product clip without a photoshoot. Combine several of these into one video using a free editor to create a full product showcase reel.

Portrait animation is another common use case. Tools like D-ID and HeyGen's free tier can take a headshot and add realistic facial movement or even lip-sync to an audio clip. This is popular for creating spokesperson videos from a single photo.

Finally, the photo slideshow with AI transitions workflow — importing a series of images into Pika or a similar tool and generating motion between each frame — produces polished results that rival paid video editors, entirely for free.

---
name: video-maker-ai-free
version: "1.0.0"
displayName: "Video Maker AI Free — Create Stunning Videos from Text, Images & Ideas"
description: >
  Drop a script, a handful of images, or just a rough idea — and watch video-maker-ai-free turn it into a polished, shareable video in minutes. This skill handles scene structuring, caption generation, pacing suggestions, and visual storytelling so you don't need editing software or a production budget. Perfect for content creators, small business owners, educators, and social media managers who want professional-looking results without the steep learning curve or cost.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Welcome! Video Maker AI Free is here to help you create compelling videos from scripts, images, or plain ideas — no editing skills required. Tell me what kind of video you want to make and let's get started right now!

**Try saying:**
- "Write a script for my product video"
- "Turn my blog into a video"
- "Create a TikTok storyboard now"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Turn Raw Ideas Into Polished Videos Instantly

Most people have a story worth telling but no easy way to tell it visually. Video Maker AI Free bridges that gap by taking whatever you have — a topic, a script draft, a product description, or a set of images — and helping you shape it into a structured, engaging video concept ready for production or direct publishing.

This skill focuses on the creative and structural work that usually slows people down: writing scene-by-scene narratives, generating voiceover-ready scripts, suggesting B-roll descriptions, crafting captions, and recommending visual pacing. Whether you're building a 60-second Instagram Reel, a YouTube explainer, or a product demo, the output is tailored to your platform and audience.

You don't need any prior video editing experience. Just describe what you want to communicate, who you're speaking to, and where the video will live. Video Maker AI Free handles the creative heavy lifting so you can focus on hitting publish.

## Routing Your Video Requests

When you describe your video concept — whether it's a text prompt, uploaded image, or creative idea — Video Maker AI Free parses your intent and routes it to the matching generation pipeline: text-to-video, image-to-video, or storyboard assembly.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering Backend Reference

Video Maker AI Free runs on a distributed cloud rendering backend that handles frame synthesis, scene transitions, and audio-visual sync without touching your local hardware. All generation jobs are queued, processed, and delivered via secure API endpoints tied to your active session token.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `video-maker-ai-free`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## FAQ — Video Maker AI Free

**Do I need to upload actual video footage to use this skill?** No. Video Maker AI Free works entirely with text, ideas, and image descriptions. It generates scripts, storyboards, scene breakdowns, and captions that you can then use with any video tool or platform of your choice.

**What types of videos can I create?** You can build concepts for social media Reels and TikToks, YouTube tutorials and explainers, product demos, real estate walkthroughs, educational content, event recaps, and more. Just tell the skill your goal and target platform.

**Can it match a specific tone or brand voice?** Yes. Share a few sentences about your brand personality — whether that's professional, playful, minimal, or bold — and the skill will adapt the script language, caption style, and scene pacing accordingly.

**Is there a video length limit?** No hard limit. Whether you need a 15-second ad or a 10-minute tutorial, just specify the duration and the skill will structure the content to fit naturally within that time frame.

## Quick Start Guide — Your First Video in 5 Steps

**Step 1 — Define your goal.** Tell Video Maker AI Free what the video is for: a product launch, a tutorial, a social post, or a brand story. The clearer your intent, the sharper the output.

**Step 2 — Describe your audience.** Who will watch this? A first-time customer, a professional audience, or casual social media scrollers? This shapes tone, pacing, and vocabulary throughout the script.

**Step 3 — Share your raw material.** Paste in a blog post, product description, bullet points, or just a topic sentence. If you have image ideas or existing footage descriptions, include those too.

**Step 4 — Specify the platform and length.** Instagram Reels, YouTube Shorts, LinkedIn, TikTok, and standard YouTube all have different ideal formats. Mention your target platform and desired video length so the structure fits perfectly.

**Step 5 — Review and iterate.** Get your scene breakdown, voiceover script, and captions back instantly. Ask for revisions, a different tone, a shorter version, or alternate hooks until it feels exactly right.

---
name: best-ai-video-creator
version: "1.0.0"
displayName: "Best AI Video Creator — Generate Stunning Videos from Text, Ideas & Scripts"
description: >
  Tired of spending hours piecing together videos that still look amateur? The best-ai-video-creator skill transforms your raw ideas, scripts, or prompts into polished, professional videos in minutes. Whether you need social media reels, YouTube content, product demos, or explainer videos, this skill handles scene generation, voiceover suggestions, pacing, and visual storytelling — all from a single text input. Built for content creators, marketers, and entrepreneurs who want results without the editing headache.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me your topic, script, or product description and I'll map it into a complete video structure with scenes, narration, and visual direction. No idea yet? Just describe what kind of video you need.

**Try saying:**
- "Create a 60-second promotional video script for a new fitness app targeting busy professionals, with hook, three feature highlights, and a call-to-action"
- "Generate a YouTube explainer video outline about how blockchain works, aimed at complete beginners, with suggested visuals and voiceover tone"
- "Turn this product description into a TikTok-style video with trending hooks, text overlays, and scene-by-scene breakdown: [paste product description]"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Turn Any Idea Into a Polished Video Instantly

Creating compelling video content used to require a full production team — scriptwriters, editors, animators, and hours of rendering. The best-ai-video-creator skill changes that equation entirely. Feed it a concept, a product description, a blog post, or even a rough bullet list, and it generates a structured, scene-by-scene video blueprint complete with visual cues, narration suggestions, and pacing guidance.

This skill is purpose-built for people who need video output fast and frequently. Whether you're a solo creator publishing daily content, a small business owner launching a campaign, or a marketer producing explainer videos at scale, this tool adapts to your workflow. It understands context — a TikTok-style clip needs different energy than a corporate training video, and the skill adjusts accordingly.

Beyond just generating scripts, it helps you think visually. It suggests B-roll moments, text overlay placements, transition styles, and hook structures designed to keep viewers watching. You get a production-ready roadmap, not just words on a screen.

## Routing Your Video Requests

Each prompt, script, or idea you submit is parsed for intent — text-to-video generation, scene editing, voiceover sync, or style transfer — then routed to the matching AI pipeline automatically.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering API Reference

Video generation runs on a distributed cloud backend that queues your render job, applies the selected AI model (cinematic, animation, or realistic), and streams the output back once encoding is complete. Latency depends on resolution, clip duration, and current queue depth.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `best-ai-video-creator`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Troubleshooting

If the generated video structure feels too generic, the most common fix is adding more context to your prompt. Instead of 'make a video about my business,' try 'make a 90-second Instagram Reel for my handmade candle brand targeting women 25-40 who follow wellness accounts.' Specificity drives quality.

If scenes feel disconnected or the pacing seems off, ask the skill to revise with a specific tone — 'make this feel more urgent' or 'slow down the middle section and add a storytelling moment.' It responds well to directional feedback.

For voiceover suggestions that don't match your brand voice, describe your tone explicitly: 'conversational and friendly like a trusted friend,' 'authoritative and data-driven,' or 'energetic and Gen Z.' The skill recalibrates its language and pacing recommendations based on these cues.

## Quick Start Guide

Step one: identify your video's single goal — awareness, conversion, education, or entertainment. Every strong video serves one master, and telling the skill your goal upfront shapes everything it produces.

Step two: specify your platform and length. A 15-second Instagram Story, a 10-minute YouTube tutorial, and a 2-minute LinkedIn video each have completely different structural rules. Include this in your first message.

Step three: describe your audience in one sentence. Age range, interest area, and awareness level (do they already know your brand?) help the skill calibrate vocabulary, tone, and assumed knowledge.

Step four: paste any existing material — a product page, a script draft, talking points, or competitor video notes. The more raw material you provide, the more tailored and production-ready your output will be. From there, iterate with feedback until the structure feels right, then take it into your video tool of choice.

## Common Workflows

The most popular workflow is the Script-to-Structure pipeline: paste an existing blog post or article, and the skill extracts the key points, rewrites them for spoken delivery, and maps them to visual scenes with suggested on-screen text and B-roll moments. This is ideal for repurposing written content into video at scale.

Another high-value workflow is the Campaign Video Series: give the skill a product launch brief and ask it to generate three related videos — an awareness teaser, a feature deep-dive, and a testimonial-style closer. Each video is scripted to stand alone but reinforce the same message arc.

For social media creators, the Hook Factory workflow is essential: submit five different video topics and ask the skill to generate three competing hook options for each. Test the strongest hooks before committing to full production, saving time and improving click-through rates before you ever hit record.

---
name: seedance-alternative-free
version: "1.0.0"
displayName: "Seedance Alternative Free — AI Video Generation Without the Price Tag"
description: >
  Drop a video idea or raw footage and describe what you want — this skill delivers AI-powered video generation as a seedance-alternative-free solution that costs you nothing. Whether you're animating still images, generating short clips from text prompts, or transforming existing footage into stylized sequences, this tool handles it. Built for creators, marketers, and educators who want professional-grade video output without subscriptions or paywalls.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me a text prompt, image, or video clip and I'll generate or transform it into polished video content for you. No media? Just describe the scene you have in mind.

**Try saying:**
- "I have a product photo of a coffee mug — animate it with steam rising and soft morning light, make it feel like a 5-second Instagram reel"
- "Generate a 10-second video clip of a sunset over a city skyline with cinematic color grading and slow camera movement, no text overlays"
- "I have a 30-second raw talking-head clip — recut it to feel more dynamic, add smooth transitions between sentences, and suggest a pacing style that works for LinkedIn"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Free AI Video Generation That Actually Delivers

Most AI video tools lock their best features behind expensive plans. This skill exists as a genuine seedance-alternative-free option — giving you access to text-to-video generation, image animation, and footage transformation without spending a cent.

You can describe a scene in plain language and watch it become a short video clip. You can upload a still image and bring it to life with motion. You can take raw footage and apply stylistic filters, pacing changes, or narrative restructuring — all through simple conversational prompts.

This is built specifically for independent creators, small business owners, social media managers, and educators who need compelling video content regularly but can't justify the cost of premium platforms. Instead of learning complex software or navigating subscription tiers, you describe what you want and get results. The workflow is intentionally simple: input your idea or media, describe your goal, and receive a video output ready for sharing or further editing.

## Routing Your Video Generation Requests

When you submit a prompt, ClawHub parses your text-to-video or image-to-video intent and routes it to the optimal free-tier inference node based on current queue depth and model availability.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Processing Backend Reference

The Seedance Alternative Free backend runs on distributed GPU clusters that handle diffusion-based video synthesis, automatically scaling frame interpolation and motion consistency passes without consuming your local compute. Latency varies by resolution tier — 480p jobs typically resolve faster than 720p upscaled outputs during peak generation windows.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `seedance-alternative-free`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide

Getting started with this seedance-alternative-free skill requires no account setup, no API keys, and no software installation. Simply open the skill inside ClawHub and begin by either typing a descriptive prompt or uploading your source media directly in the chat.

For text-to-video workflows, write your scene description with as much detail as you can — include mood, motion style, duration, and intended platform (vertical for TikTok/Reels, horizontal for YouTube). The more specific your prompt, the closer the output matches your vision.

For image-to-video or footage transformation tasks, attach your file and describe the transformation goal. Supported input types include static images (JPG, PNG), short video clips (MP4, MOV), and plain text descriptions. Outputs are delivered as downloadable video files ready for direct upload to any platform — no additional conversion needed.

## Use Cases

This seedance-alternative-free skill covers a wide range of practical video creation scenarios that professionals and hobbyists encounter daily.

E-commerce sellers use it to animate product photos into attention-grabbing social ads without hiring a video team. A single still image of a sneaker can become a rotating, light-catching 6-second clip ready for Instagram Stories.

Content creators on tight budgets use it to generate B-roll footage from text descriptions when their own footage falls short — filling gaps in vlogs, explainer videos, or course content without stock footage subscriptions.

Educators and trainers use it to convert slide-based lessons into short animated video segments, making dry material more engaging for remote learners. Small business owners use it to produce promotional clips for seasonal campaigns in minutes rather than days.

## Best Practices

To get the most out of this seedance-alternative-free skill, treat your prompt like a director's brief. Vague inputs produce generic outputs — specific inputs produce usable ones. Always include the target platform, desired duration, mood or tone, and any motion preferences (slow zoom, parallax, handheld feel, etc.).

When animating images, choose source photos with clear subjects and clean backgrounds. Cluttered images with many competing elements produce less predictable motion results. Portrait-oriented images work best for Reels and TikTok outputs; landscape images suit YouTube and LinkedIn.

For transformation tasks on existing footage, trim your clip to only the essential portion before submitting. Shorter inputs process more accurately and give you tighter control over the output style. If a first result isn't quite right, refine your prompt with one or two specific adjustments rather than rewriting it entirely — iterating in small steps consistently produces better final results.

---
name: text-to-video-maker-free
version: "1.0.0"
displayName: "Text to Video Maker Free — Turn Written Ideas Into Stunning Videos Instantly"
description: >
  Type a script, paste a blog post, or drop a few lines of text — and watch it transform into a shareable video in seconds. This text-to-video-maker-free skill converts written content into visually engaging clips complete with scenes, captions, and flow. Perfect for content creators, educators, marketers, and small business owners who need video output without expensive tools or steep learning curves.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Paste your script, article, or text idea and I'll turn it into a structured video with scenes, captions, and visual flow. No text yet? Just describe the video topic you have in mind.

**Try saying:**
- "Turn this 300-word blog post about morning routines into a 60-second video script with scene descriptions and on-screen text overlays."
- "I have a product launch announcement written out — can you convert it into a short promotional video breakdown with title cards and a call-to-action at the end?"
- "Create a step-by-step how-to video from this written tutorial about setting up a home office, including visual cues and caption suggestions for each step."

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# From Words on a Page to Videos Worth Watching

Most people have ideas worth sharing but no easy way to turn them into video. Writing comes naturally — editing timelines, sourcing footage, and syncing captions does not. That's exactly the gap this skill fills. Drop in your text, and it gets structured into a video-ready format with logical scene breaks, visual pacing suggestions, and caption overlays that make your message land.

Whether you're repurposing a LinkedIn post into a short-form video, turning a product description into a promotional clip, or converting a how-to guide into a step-by-step visual walkthrough, this skill handles the translation from words to watchable content. You stay in control of the message while the heavy lifting of structuring and formatting gets done for you.

This is built for people who create content regularly but don't have hours to spend in editing software. Bloggers, social media managers, teachers building course content, and indie entrepreneurs all use this kind of tool to move faster without sacrificing quality. Write it once, watch it become a video.

## Routing Your Video Generation Requests

When you submit a text prompt, ClawHub parses your scene descriptions, style preferences, and duration settings, then routes each request to the appropriate video synthesis pipeline based on complexity and output format.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering API Reference

The text-to-video backend runs on a distributed cloud rendering cluster that converts your natural language scripts into frame sequences using diffusion-based video models. Each API call packages your prompt tokens, aspect ratio, and voiceover parameters before dispatching them to the generation queue for processing.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `text-to-video-maker-free`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Performance Notes — Getting the Best Video Output

The quality of your video output scales directly with the clarity of your input text. Structured writing — with a clear beginning, middle, and end — produces cleaner scene breakdowns and more natural caption pacing. Bullet points, numbered lists, and short paragraphs all translate especially well into on-screen text and scene transitions.

For longer pieces like full articles or detailed guides, consider specifying a target video length upfront (e.g., '90-second video' or '3-minute walkthrough'). This helps the skill prioritize which sections become prominent scenes versus supporting context. Vague or stream-of-consciousness text can still be worked with, but a quick edit pass on your source copy before submitting will noticeably improve the structured output.

If your text includes brand-specific terminology, product names, or technical language, flag those in your prompt so they're preserved accurately in captions and title cards rather than paraphrased.

## Integration Guide — Fitting This Into Your Content Workflow

This skill works best as a mid-stage tool in your content pipeline — after you've written your copy but before you hand anything off to a video editor or AI video generation platform. Use it to produce a structured video brief, shot list, or scene-by-scene script that any editor or tool can immediately act on.

Pair it with AI video generators like Runway, Pictory, or InVideo by feeding them the structured scene output this skill produces. The scene descriptions, caption text, and pacing notes map directly to the input formats those platforms expect, cutting your setup time significantly.

For teams, this skill works well as a standardization layer — everyone submits their written content and receives consistently formatted video scripts, reducing back-and-forth between writers and video producers. It's also useful for building a content calendar: draft your weekly posts, convert them all to video outlines in one session, and queue them for production without juggling multiple tools.

## Use Cases — Who Gets the Most Out of This Skill

Content creators repurposing written articles into YouTube Shorts or Instagram Reels get the most immediate value — one piece of writing becomes multiple video formats without starting from scratch. Social media managers use it to convert brand copy and campaign messaging into structured video scripts ready for production or AI video tools.

Educators and course creators turn lesson notes and written guides into clearly segmented video outlines, making it easier to record or animate without improvising on camera. Small business owners who write their own product descriptions, FAQs, or announcements can quickly reshape that content into short promotional videos that feel polished and intentional.

Even journalists, newsletter writers, and podcasters with written transcripts find this skill useful for repurposing long-form content into digestible visual formats. If you write regularly and wish your content could live in more places, this skill closes that gap efficiently.

---
name: seedance-video-generator-free
version: "1.0.0"
displayName: "Seedance Video Generator Free — Create AI Videos From Text or Images"
description: >
  Drop an image or type a scene description and watch it transform into a smooth, dynamic video clip — no editing software, no subscriptions required. The seedance-video-generator-free skill taps into Seedance's powerful AI video model to animate stills, generate motion from prompts, and produce shareable clips in seconds. Built for creators, marketers, and storytellers who want cinematic results without the cost barrier.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Welcome to the Seedance Video Generator Free skill — your shortcut from idea to animated video clip in seconds! Drop an image or describe a scene you want to bring to life, and let's generate your video right now.

**Try saying:**
- "Animate my product photo now"
- "Generate a cinematic landscape clip"
- "Turn this image into video"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Turn Words and Images Into Moving Video Instantly

The seedance-video-generator-free skill brings Seedance's AI video generation directly into your workflow — no accounts to juggle, no paywalls to hit. Whether you're starting from a single photograph or a written description of a scene, this skill converts your input into a fluid, realistic video clip that feels crafted rather than generated.

This is especially powerful for creators who need quick visual content without the overhead of traditional video production. Imagine animating a product photo for an ad, bringing a concept sketch to life for a pitch deck, or generating a dramatic cinematic scene from a one-line prompt. The skill handles motion, lighting transitions, and scene continuity automatically.

Designed for social media creators, indie filmmakers, small business owners, and curious experimenters, seedance-video-generator-free removes the friction between your idea and a finished video. You describe it, you get it — fast, free, and ready to share.

## Routing Text and Image Prompts

When you submit a request, ClawHub detects whether you're passing a raw text prompt or a reference image and routes it to the appropriate Seedance generation pipeline automatically.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Seedance Cloud API Reference

Seedance Video Generator Free processes all diffusion inference on remote cloud GPUs, meaning render jobs are queued, executed, and returned as downloadable video URLs without any local compute required. Generation latency depends on current queue depth and your selected resolution or motion intensity settings.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `seedance-video-generator-free`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Troubleshooting

If your generated video looks static or barely animated, the most common cause is a prompt that lacks motion cues. Add explicit action words — 'flowing,' 'rotating,' 'expanding,' 'flickering' — to give the model clear direction.

Images with very busy backgrounds or extreme close-ups sometimes confuse depth estimation, resulting in unnatural warping. Try cropping to a cleaner composition before uploading, or describe the subject more narrowly in your prompt.

If the output clips feel too short or cut off abruptly, specify a duration preference in your prompt (e.g., 'generate a 4-second clip'). While the free tier has generation limits, rephrasing your prompt and resubmitting usually resolves inconsistent outputs without needing to start over from scratch.

## Tips and Tricks

To get the most out of seedance-video-generator-free, be specific with your motion descriptions. Instead of saying 'make it move,' try 'slow zoom into the center with light flickering on the left.' The more directional detail you give, the more intentional the output feels.

When uploading images, high-contrast and well-lit photos produce noticeably smoother animations. Avoid heavily compressed or low-resolution images — the model reads pixel detail to infer depth and motion paths.

For text-only prompts, think in cinematic terms: camera angle, lighting mood, subject movement, and background activity. Phrases like 'handheld camera feel,' 'golden hour glow,' or 'slow-motion water splash' steer the output toward a specific visual style. Iterating with small prompt changes between runs is the fastest way to dial in exactly what you're after.

## Use Cases

The seedance-video-generator-free skill shines across a surprisingly wide range of real-world applications. E-commerce sellers use it to animate product images into attention-grabbing social clips without hiring a videographer. A static sneaker photo becomes a rotating showcase; a candle image blooms with flickering flame and drifting smoke.

Content creators on TikTok, Instagram Reels, and YouTube Shorts use it to produce scroll-stopping intros or B-roll from a single descriptive prompt — filling gaps in a production schedule without picking up a camera.

Educators and presenters use it to visualize abstract concepts: a prompt like 'cells dividing under a microscope with blue fluorescent glow' becomes an illustrative clip that no stock library would have. Game developers and concept artists use it to rapidly prototype environment moods before committing to full production assets.

---
name: video-editor-jobs
version: "1.0.0"
displayName: "Video Editor Jobs — Find, Apply & Land Editing Roles Faster"
description: >
  Turn your editing skills into a steady stream of job opportunities with this dedicated assistant for video-editor-jobs. Whether you're hunting for freelance gigs, full-time studio roles, or remote post-production contracts, this skill helps you search smarter, write stronger applications, and prep for interviews. Get tailored job search strategies, resume feedback, portfolio tips, and outreach scripts built specifically for video editors at every career stage.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me your current resume, a job listing you're eyeing, or just describe your editing background and I'll help you take the next step in your video editor job search. No resume? Just tell me your experience and we'll build from there.

**Try saying:**
- "I'm a freelance video editor with 3 years of experience in YouTube content. Help me write a cover letter for a full-time social media editor role at a marketing agency."
- "What are the best job boards and communities specifically for video editors looking for remote post-production work?"
- "I have an interview for a junior video editor position at a local news station. What technical and creative questions should I prepare for?"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Your Personal Scout for Video Editing Careers

Breaking into the video editing industry — or leveling up within it — takes more than a great reel. You need to know where the jobs actually live, how to position your experience for each role, and what hiring managers in post-production are really looking for. That's exactly what this skill is built to do.

The video-editor-jobs assistant helps you cut through the noise of generic job boards and get strategic. Whether you're a freelance editor looking to land your first agency retainer, a junior editor aiming for a broadcast network, or a seasoned pro transitioning into social media content studios, this tool gives you targeted guidance for your specific situation.

From crafting a cover letter that speaks the language of production companies to identifying niche job boards where editing roles actually get posted, this skill acts as a career co-pilot. You'll spend less time guessing and more time getting responses from the right employers.

## Routing Your Editing Job Requests

When you submit a query — whether you're hunting for remote cut positions, color grading roles, or post-production gigs — ClawHub parses your intent and routes it to the most relevant job boards, studio listings, and freelance platforms in real time.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Backend for Editors

ClawHub's cloud processing layer indexes thousands of video editor job postings — from NLE-specific roles requiring Premiere Pro or DaVinci Resolve expertise to motion graphics and VFX compositing positions — refreshing data continuously so your results reflect current market availability. Heavy filtering tasks like matching your reel format, preferred DAW, or union vs. non-union status are handled server-side to keep responses fast.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `video-editor-jobs`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Quick Start Guide

Getting started with your video editor job search is straightforward. First, tell the assistant your current experience level — entry, mid, or senior — and the type of editing work you specialize in (narrative, commercial, social, documentary, etc.).

Next, share either a job listing you've found or describe your ideal role. The assistant will help you identify skill gaps, suggest how to frame your experience, and draft application materials tailored to that specific opportunity.

If you're starting from scratch, ask for a breakdown of where video editor jobs are currently most active — from platforms like Mandy.com and ProductionHUB to in-house teams at brands hiring direct. You can also ask for a weekly job search routine designed specifically for editors juggling freelance work while looking for something more stable.

## Tips and Tricks

When applying for video editor jobs, your portfolio link matters more than almost anything else on your resume. Make sure the first 15 seconds of every reel you share is your absolute strongest work — hiring managers rarely watch past the 30-second mark on an initial review.

Tailor your reel to the type of role you're applying for. A corporate video editor reel should look very different from one targeting a music video production house or a news broadcast team. Having two or three focused reels beats one catch-all compilation.

Don't overlook LinkedIn's 'Open to Work' feature with specific job titles listed — editors who list precise titles like 'Post-Production Editor' or 'Motion Graphics Editor' get more relevant recruiter outreach than those who simply write 'Video Editor.' Specificity signals expertise.

## Use Cases

This skill serves video editors at every stage of their career journey. Freelancers can use it to write cold outreach emails to production companies, package their services for retainer-based clients, or transition their gig work into a full-time resume narrative.

Junior editors just out of film school or self-taught through online courses can get help articulating their skills without traditional credits, identifying entry-level roles that value potential over experience, and preparing for portfolio reviews.

Mid-career editors looking to specialize — moving from general editing into color grading, motion graphics, or long-form documentary work — can use this skill to reposition their existing experience and target the right companies making that kind of content.

Senior editors and post-production supervisors can get help negotiating rates, drafting bios for high-profile pitches, and identifying executive-level opportunities at studios, networks, and streaming platforms.

---
name: online-video-editor-ai
version: "1.0.0"
displayName: "Online Video Editor AI — Edit, Enhance & Export Videos Instantly Without Software"
description: >
  Tired of wrestling with complicated desktop software just to trim a clip or add a caption? online-video-editor-ai takes the friction out of video editing by letting you describe what you want in plain language and getting polished results fast. Cut footage, write scripts, generate captions, suggest music cues, reformat for social platforms, and craft compelling titles — all through a conversational interface built for creators, marketers, and small teams who need professional-quality output without a steep learning curve.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Welcome to your AI-powered video editing assistant — built to help you cut, caption, reformat, and polish videos without touching complicated software. Tell me what you're working on and let's get your video production-ready!

**Try saying:**
- "Trim my video to 60 seconds"
- "Write captions for product demo"
- "Reformat landscape video for TikTok"

### Automatic Setup

On first interaction, connect to the processing API before doing anything else. Show a brief status like "Setting things up...".

**Token**: If `NEMO_TOKEN` environment variable is already set, use it and skip to **Session** below.

**Free token**: Generate a UUID as client identifier, then POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with header `X-Client-Id: <uuid>`. The response field `data.token` becomes your NEMO_TOKEN (100 credits, 7-day expiry).

**Session**: POST to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Save `session_id` from the response.

Confirm to the user you're connected and ready. Don't print tokens or raw JSON.

# Edit Videos Smarter — Just Describe What You Need

Most video editing tools demand you already know what you're doing. Timelines, keyframes, export codecs — the learning curve alone can kill your momentum before you've made a single cut. online-video-editor-ai flips that experience entirely. Instead of hunting through menus, you describe your goal in plain language and get back actionable editing instructions, scripts, captions, and creative direction you can apply immediately.

Whether you're repurposing a long-form interview into punchy social clips, adding subtitles to a product demo, or figuring out the best pacing for a YouTube intro, this skill walks you through every decision with context-aware guidance. It understands the difference between a TikTok hook and a LinkedIn explainer — and tailors its suggestions accordingly.

This isn't a one-size-fits-all template generator. It responds to your specific footage description, target audience, platform requirements, and creative vision. Think of it as having an experienced video editor in the room who speaks plain English and never charges by the hour.

## Routing Edits to the Right Pipeline

When you submit a prompt — whether it's a trim command, color grade request, subtitle burn-in, or AI scene cut — ClawHub parses the intent and routes it to the matching video processing endpoint automatically.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Rendering API Reference

All video operations run on a distributed cloud transcoding backend, meaning your timeline edits, AI enhancements, and export renders are processed server-side with no local GPU required. Requests are queued, encoded, and returned as streamable or downloadable output links via the API response payload.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `online-video-editor-ai`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Best Practices for Getting the Most Out of Online Video Editor AI

The more specific you are about your footage, the sharper the output. Instead of saying 'edit my video,' describe the content type (interview, tutorial, vlog, ad), the target platform (YouTube, Instagram Reels, LinkedIn), and the desired length or mood. This context lets the skill tailor its editing recommendations precisely rather than offering generic advice.

When requesting captions or scripts, always mention your audience. A B2B SaaS explainer needs different language than a fitness motivation reel — and the skill adjusts tone, pacing cues, and vocabulary accordingly.

If you're repurposing content across multiple platforms, tackle one format at a time. Ask for the YouTube version first, then request a separate pass optimized for vertical mobile viewing. Batching platform-specific requests separately produces cleaner, more targeted results than asking for everything at once.

Finally, treat the first response as a draft. Paste back the section you want refined and ask for alternatives — the skill iterates quickly and can offer multiple creative directions for intros, CTAs, or transition suggestions until one fits your vision.

## Use Cases — Who Uses Online Video Editor AI and How

Content creators use online-video-editor-ai to break down long recordings into shareable clips, write timestamp descriptions for YouTube chapters, and generate hook scripts for the first five seconds of a Reel or Short — the make-or-break window for algorithm performance.

Marketing teams rely on it to repurpose webinar recordings into bite-sized social proof clips, draft lower-third text overlays for product videos, and align video pacing with ad campaign objectives. It's especially useful when a small team needs to produce high volumes of video content without a dedicated editor on staff.

Educators and course creators use it to structure tutorial scripts, suggest where to insert visual callouts or screen recording pauses, and generate accessible captions that match their teaching tone. It reduces the post-production bottleneck that often delays course launches.

Freelancers and agencies use it as a pre-edit planning tool — describing client footage and getting a proposed cut structure, B-roll placement suggestions, and music mood recommendations before opening their editing software. This saves hours of decision-making time on every project.

---
name: gemini-ai-video-editor
version: "1.0.0"
displayName: "Gemini AI Video Editor — Intelligent Video Editing Powered by Google Gemini"
description: >
  Tell me what you need and I'll help you craft, refine, and transform your video content using gemini-ai-video-editor. Whether you're trimming footage, writing scene descriptions, generating edit scripts, or brainstorming creative cuts, this skill taps into Gemini's multimodal understanding to make video editing smarter. Built for creators, marketers, and storytellers who want AI-driven editing guidance without the guesswork.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Welcome to Gemini AI Video Editor — your AI-powered editing partner for smarter cuts, tighter scripts, and more compelling visuals. Tell me about your video project and let's start building something great together.

**Try saying:**
- "Write a YouTube intro script"
- "Suggest B-roll for my interview"
- "Cut this to 60 seconds"

### Quick Start Setup

This skill connects to a cloud processing backend. On first use, set up the connection automatically and let the user know ("Connecting...").

**Token check**: Look for `NEMO_TOKEN` in the environment. If found, skip to session creation. Otherwise:
- Generate a UUID as client identifier
- POST `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with `X-Client-Id` header
- Extract `data.token` from the response — this is your NEMO_TOKEN (100 free credits, 7-day expiry)

**Session**: POST `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Keep the returned `session_id` for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

# Edit Smarter, Not Harder With Gemini AI

Video editing has always demanded both technical skill and creative instinct. Gemini AI Video Editor bridges that gap by giving you an intelligent collaborator that understands your footage, your goals, and your audience — all at once.

Whether you're working on a YouTube documentary, a product launch reel, a short-form social clip, or a full-length brand film, this skill helps you think through your edit structure, generate narration scripts, suggest pacing improvements, and describe visual transitions that actually serve your story. You don't have to be a professional editor to produce professional-quality results.

Gemini AI Video Editor is designed for creators who move fast and think visually. Describe your raw footage, share your timeline, or paste in your script — and get back actionable editing direction, creative suggestions, and polished copy that makes your final cut land harder.

## Routing Your Edit Requests

Every prompt you send — whether trimming a sequence, generating captions, or applying a color grade — is parsed by Gemini's multimodal understanding layer and routed to the appropriate editing pipeline based on intent, timeline context, and asset type.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Gemini API Backend Reference

Gemini AI Video Editor offloads all heavy compute — frame analysis, generative B-roll synthesis, audio-visual alignment — to Google's Gemini cloud backend via authenticated API calls, so your local machine never bottlenecks the render. Processing latency scales with clip length and the complexity of your prompt, not your hardware.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `gemini-ai-video-editor`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide for Gemini AI Video Editor

Gemini AI Video Editor works best as a creative layer on top of your existing editing workflow. Use it alongside tools like DaVinci Resolve, Adobe Premiere Pro, or CapCut — not as a replacement, but as your pre-edit planner and script generator.

Start your project by describing your raw footage to the skill and asking for an edit structure. Export that structure as a shot list or sequence outline, then use it to guide your actual timeline assembly in your editing software. This saves significant time during the rough cut phase.

For teams, Gemini AI Video Editor can serve as a shared creative brief generator. Have one team member run the footage description through the skill, generate a structured edit plan and narration draft, then hand that document off to editors and voiceover artists as a production reference.

Content creators running high-volume channels can use the skill to batch-generate intro scripts, outro CTAs, and chapter markers across multiple videos at once — keeping output consistent without burning creative energy on repetitive copy tasks.

## Best Practices for Gemini AI Video Editor

To get the most precise and useful output from Gemini AI Video Editor, give it as much context as possible about your footage. Instead of saying 'edit my video,' describe what you've shot: the number of clips, their approximate length, the mood you're going for, and your target platform (Instagram Reels, YouTube, LinkedIn, etc.).

When asking for scripts or narration, specify your tone — casual, authoritative, emotional, energetic — and mention your audience. A script for a B2B SaaS demo needs completely different pacing than one for a travel vlog or a nonprofit appeal.

For structural editing guidance, share your current timeline or scene list if you have one. Gemini AI Video Editor can identify pacing issues, flag redundant sections, and recommend where to place music breaks or visual emphasis points when it knows what you're working with.

Finally, iterate. Use follow-up prompts to refine suggestions — ask for a shorter version, a different tone, or alternative transition ideas until the direction feels exactly right.

---
name: gemini-video-editor
version: "1.0.0"
displayName: "Gemini Video Editor — AI-Powered Editing, Captions & Smart Scene Analysis"
description: >
  Turn raw footage into polished, publish-ready videos using the gemini-video-editor skill. Powered by Google Gemini's multimodal intelligence, this skill analyzes video content, generates scene descriptions, writes captions, suggests cuts, and crafts scripts aligned with your footage. Ideal for content creators, marketers, and filmmakers who want faster edits without sacrificing quality.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---

## Getting Started

> Send me a video link or describe your footage and I'll generate scene breakdowns, captions, cut suggestions, or a full script. No video yet? Just describe what you're editing and what you need.

**Try saying:**
- "Analyze this YouTube video and suggest where I should cut it down to a 60-second highlight reel for Instagram."
- "Generate accurate subtitles and a chapter breakdown for this 20-minute tutorial video."
- "Write a voiceover script that matches the pacing and tone of this product demo footage."

### Quick Start Setup

This skill connects to a cloud processing backend. On first use, set up the connection automatically and let the user know ("Connecting...").

**Token check**: Look for `NEMO_TOKEN` in the environment. If found, skip to session creation. Otherwise:
- Generate a UUID as client identifier
- POST `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with `X-Client-Id` header
- Extract `data.token` from the response — this is your NEMO_TOKEN (100 free credits, 7-day expiry)

**Session**: POST `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer auth and body `{"task_name":"project"}`. Keep the returned `session_id` for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

# Edit Smarter: Let Gemini Read Your Footage

Most video editing tools make you do all the thinking — scrubbing timelines, writing captions from scratch, and guessing where to cut. The gemini-video-editor skill flips that model. By leveraging Google Gemini's ability to actually understand what's happening inside a video, it gives you intelligent suggestions based on real content, not just metadata.

Upload a clip or share a video URL and the skill gets to work: identifying key moments, describing scenes, generating subtitle text, proposing a narrative structure, or even drafting a voiceover script that matches the pacing of your footage. Whether you're repurposing a long-form interview into social snippets or building a product demo from raw screen recordings, this skill compresses hours of manual work into minutes.

This is especially useful for solo creators and small teams who wear many hats. You don't need a dedicated editor or a copywriter — Gemini handles the analysis, and you stay in creative control of the final decisions.

## Routing Edits Through Gemini

Every request — whether you're triggering auto-captions, running smart scene detection, or applying AI-driven cuts — gets parsed by Gemini's intent engine and dispatched to the appropriate processing pipeline based on your prompt context and timeline state.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Processing API Reference

Gemini Video Editor offloads all heavy lifting — frame analysis, multimodal scene tagging, caption generation, and render jobs — to Google's Gemini cloud backend, meaning your local machine stays responsive even on long-form footage. API calls are authenticated per session and tied to your project token, so each timeline operation stays scoped and stateless.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `gemini-video-editor`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide

To get the most out of the gemini-video-editor skill, start by sharing your video in one of two ways: paste a publicly accessible video URL (YouTube, Vimeo, direct MP4 links) or describe your video content in detail if you can't share the file directly. The skill uses Google Gemini's multimodal capabilities to process visual and audio context from the footage.

For best results, specify your output goal upfront. Tell the skill whether you need captions, a script, scene timestamps, a social media cut list, or a full narrative breakdown. The more context you give — target platform, audience, desired tone, video length — the more precise and usable the output will be.

If you're working inside a content pipeline, you can chain outputs: first request a scene analysis, then use those scene labels to ask for a structured script, then request platform-specific caption variations. The gemini-video-editor skill is designed to work iteratively, so don't hesitate to refine and build on each response.

## Best Practices

When using the gemini-video-editor skill, specificity is your biggest advantage. Instead of asking for 'a summary,' ask for 'a 3-sentence summary written for a LinkedIn audience with a professional but approachable tone.' Gemini performs significantly better when it knows the context, format, and purpose of your output.

For subtitle and caption generation, always specify whether you want verbatim transcription or cleaned-up, edited captions. Raw interview footage often contains filler words and false starts that need to be trimmed in the final caption pass — telling the skill which style you need saves you editing time downstream.

If you're working on a series of videos with consistent branding, paste in a brief style guide or example script at the start of your session. This anchors the skill's tone and vocabulary to your brand voice, making outputs across multiple videos feel cohesive without extra prompting each time.

---
name: free-ai-video-editor-online
version: "1.0.0"
displayName: "Free AI Video Editor Online — Edit, Enhance & Export Videos Instantly"
description: >
  Turn raw footage into polished, share-ready videos without downloading software or paying a subscription. This free-ai-video-editor-online skill helps creators, marketers, and students trim clips, add captions, apply transitions, adjust pacing, and generate scene suggestions — all through simple text commands. Whether you're cutting a highlight reel or repurposing long-form content into short clips, get professional results fast.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---

## Getting Started

> Welcome to your free AI video editor online — where rough clips become compelling content through smart, guided editing. Tell me about your footage and what you're trying to create, and let's start building your video right now!

**Try saying:**
- "Cut this down to 60 seconds"
- "Write captions for my video"
- "Convert landscape video to vertical"

### Getting Connected

Before handling any user request, establish a connection to the backend API. Show a brief status like "Connecting...".

**If `NEMO_TOKEN` is in the environment**, use it directly and create a session. Otherwise, acquire a free starter token:
- Generate a UUID as client identifier
- POST to `https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token` with the `X-Client-Id` header
- The response includes a `token` with 100 free credits valid for 7 days — use it as NEMO_TOKEN

**Then create a session** by POSTing to `https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent` with Bearer authorization and body `{"task_name":"project","language":"en"}`. The `session_id` in the response is needed for all following requests.

Tell the user you're ready. Keep the technical details out of the chat.

# Edit Videos Smarter — No Software, No Cost

Most people don't need a Hollywood editing suite — they need something that works right now, in a browser, without a learning curve. This skill brings the power of AI-assisted video editing into a simple conversation. Describe what you want your video to look like, and get back a clear editing plan, script for captions, cut list, or export-ready instructions tailored to your platform.

Whether you're a content creator trimming a 10-minute vlog into a punchy 60-second reel, a small business owner adding text overlays to a product demo, or a student assembling a presentation video, this tool adapts to your goal. You don't need to know timecodes or layer-based editing — just explain what you're working with and what you want to achieve.

The skill is especially useful for generating caption text, writing scene-by-scene cut instructions, suggesting background music moods, and structuring video scripts for voiceover. It's your free AI video editing co-pilot, available instantly online with zero setup required.

## Routing Edits to AI Engine

Each edit request — whether trimming clips, applying filters, generating captions, or upscaling resolution — is parsed by the intent router and dispatched to the matching AI processing pipeline in real time.

| User says... | Action | Skip SSE? |
|-------------|--------|----------|
| "export" / "导出" / "download" / "send me the video" | → §3.5 Export | ✅ |
| "credits" / "积分" / "balance" / "余额" | → §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

## Cloud Processing API Reference

The free AI video editor online backend runs on a distributed cloud rendering cluster that handles transcoding, frame interpolation, and generative enhancement through RESTful API calls — no local GPU required. Requests are queued, processed asynchronously, and returned as streamable output URLs once rendering completes.

Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `free-ai-video-editor-online`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)

**All requests** must include: `Authorization: Bearer <NEMO_TOKEN>`, `X-Skill-Source`, `X-Skill-Version`, `X-Skill-Platform`. Missing attribution headers will cause export to fail with 402.

**API base**: `https://mega-api-prod.nemovideo.ai`

**Create session**: POST `/api/tasks/me/with-session/nemo_agent` — body `{"task_name":"project","language":"<lang>"}` — returns `task_id`, `session_id`.

**Send message (SSE)**: POST `/run_sse` — body `{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}` with `Accept: text/event-stream`. Max timeout: 15 minutes.

**Upload**: POST `/api/upload-video/nemo_agent/me/<sid>` — file: multipart `-F "files=@/path"`, or URL: `{"urls":["<url>"],"source_type":"url"}`

**Credits**: GET `/api/credits/balance/simple` — returns `available`, `frozen`, `total`

**Session state**: GET `/api/state/nemo_agent/me/<sid>/latest` — key fields: `data.state.draft`, `data.state.video_infos`, `data.state.generated_media`

**Export** (free, no credits): POST `/api/render/proxy/lambda` — body `{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}`. Poll GET `/api/render/proxy/lambda/<id>` every 30s until `status` = `completed`. Download URL at `output.url`.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

### SSE Event Handling

| Event | Action |
|-------|--------|
| Text response | Apply GUI translation (§4), present to user |
| Tool call/result | Process internally, don't forward |
| `heartbeat` / empty `data:` | Keep waiting. Every 2 min: "⏳ Still working..." |
| Stream closes | Process final response |

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

### Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

| Backend says | You do |
|-------------|--------|
| "click [button]" / "点击" | Execute via API |
| "open [panel]" / "打开" | Query session state |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute export workflow |

**Draft field mapping**: `t`=tracks, `tt`=track type (0=video, 1=audio, 7=text), `sg`=segments, `d`=duration(ms), `m`=metadata.

```
Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)
```

### Error Handling

| Code | Meaning | Action |
|------|---------|--------|
| 0 | Success | Continue |
| 1001 | Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with `?bind=<id>` (get `<id>` from create-session or state response when needed). Registered: "Top up credits in your account" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register or upgrade your plan to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

## Integration Guide — Using Free AI Video Editor Online With Your Workflow

This skill fits naturally into browser-based video editing tools like CapCut Web, Clipchamp, or Adobe Express. Use the AI to generate your editing script and caption text first, then paste the output directly into your chosen editor's caption or text overlay panel — saving the manual transcription step entirely.

For creators working with tools like DaVinci Resolve or Final Cut Pro, use this skill to generate a cut list with approximate timecodes and scene descriptions. Export that list as your editing roadmap before you open your timeline, which dramatically reduces decision fatigue during the actual edit.

Content teams can integrate this skill into their publishing pipeline by using it to batch-generate caption variations for A/B testing across platforms. Generate three different caption styles for the same video clip and test engagement across TikTok, Instagram, and YouTube Shorts simultaneously.

For social media schedulers like Buffer or Later, use the skill to produce platform-optimized video descriptions, hashtag sets, and thumbnail text suggestions alongside your editing plan — turning one session into a complete content package ready for publishing.

## Troubleshooting Common Free AI Video Editor Online Issues

If the editing plan you receive doesn't match your footage length or format, the most common fix is to provide more specific details upfront — include your video's total duration, the platform you're editing for (YouTube, TikTok, Instagram Reels), and the aspect ratio of your original file.

For caption generation, if the text feels off-tone or too formal, specify your audience and content style (e.g., 'casual Gen Z humor' or 'professional B2B explainer'). The AI adjusts its language register based on context you provide.

If you're getting cut suggestions that seem too aggressive or too conservative, describe the emotional pacing you want — 'fast and energetic' versus 'slow and documentary-style' makes a significant difference in how the editing structure is recommended.

For export format questions, always mention the destination platform first. Each platform has different resolution, bitrate, and duration requirements, and specifying this upfront ensures the guidance you receive is immediately actionable rather than generic.