@clawhub-whitejohnk-26-63aff3dc4c
create images or clips into AI-generated videos with this create-ai-video-free skill. Works with MP4, MOV, JPG, PNG files up to 500MB. content creators and m...
---
name: create-ai-video-free
version: "1.0.0"
displayName: "Create AI Video Free — Generate Videos from Images or Clips"
description: >
create images or clips into AI-generated videos with this create-ai-video-free skill. Works with MP4, MOV, JPG, PNG files up to 500MB. content creators and marketers use it for generating videos from images or text without manual editing — 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
> Send me your images or clips and I'll handle the AI video creation. Or just describe what you're after.
**Try saying:**
- "create five product photos and a logo file into a 1080p MP4"
- "turn these photos into a 30-second promo video with background music"
- "generating videos from images or text without manual editing for content creators and marketers"
### 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.
# Create AI Video Free — Generate Videos from Images or Clips
Send me your images or clips and describe the result you want. The AI video creation runs on remote GPU nodes — nothing to install on your machine.
A quick example: upload five product photos and a logo file, type "turn these photos into a 30-second promo video with background music", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.
Worth noting: using fewer images with clear subjects speeds up generation significantly.
## Matching Input to Actions
User prompts referencing create ai video 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.
Three attribution headers are required on every request and must match this file's frontmatter:
| Header | Value |
|--------|-------|
| `X-Skill-Source` | `create-ai-video-free` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |
**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.
### 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.
### 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
**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)
```
## Common Workflows
**Quick edit**: Upload → "turn these photos into a 30-second promo video with background music" → 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 "turn these photos into a 30-second promo video with background music" — concrete instructions get better results.
Max file size is 500MB. Stick to MP4, MOV, JPG, PNG for the smoothest experience.
Export as MP4 for widest compatibility across social platforms.
Cloud-based ai-video-creator-from-text tool that handles generating videos from written content or scripts. Upload TXT, DOCX, PDF, copied text files (up to 5...
---
name: ai-video-creator-from-text
version: "1.0.0"
displayName: "AI Video Creator from Text — Turn Text into Shareable Videos"
description: >
Cloud-based ai-video-creator-from-text tool that handles generating videos from written content or scripts. Upload TXT, DOCX, PDF, copied text files (up to 500MB), describe what you need, and get 1080p MP4 output in 1-2 minutes. Built for marketers, content creators, educators 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 creation. Or just tell me what you're thinking.
**Try saying:**
- "create my text prompts"
- "export 1080p MP4"
- "turn this blog post intro into"
### 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.
# AI Video Creator from Text — Turn Text into Shareable Videos
Send me your text prompts and describe the result you want. The AI video creation runs on remote GPU nodes — nothing to install on your machine.
A quick example: upload a 150-word product description, type "turn this blog post intro into a 30-second video with visuals and voiceover", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.
Worth noting: shorter, clearer text prompts produce more accurate visuals than long paragraphs.
## Matching Input to Actions
User prompts referencing ai video creator from text, 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.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `ai-video-creator-from-text`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `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 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
## Tips and Tricks
The backend processes faster when you're specific. Instead of "make it look better", try "turn this blog post intro into a 30-second video with visuals and voiceover" — concrete instructions get better results.
Max file size is 500MB. Stick to TXT, DOCX, PDF, copied text for the smoothest experience.
Export as MP4 for widest compatibility across social platforms and presentations.
## Common Workflows
**Quick edit**: Upload → "turn this blog post intro into a 30-second video with visuals and voiceover" → 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.
create images or clips into finished MP4 video with this ai-video-maker-free-online skill. Works with MP4, MOV, JPG, PNG files up to 500MB. content creators...
---
name: ai-video-maker-free-online
version: "1.0.0"
displayName: "AI Video Maker Free Online — Create and Export Videos Online"
description: >
create images or clips into finished MP4 video with this ai-video-maker-free-online skill. Works with MP4, MOV, JPG, PNG files up to 500MB. content creators and small business owners use it for creating short videos from photos or clips without editing software — 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
> Got images or clips to work with? Send it over and tell me what you need — I'll take care of the AI video creation.
**Try saying:**
- "create five product photos and a logo file into a 1080p MP4"
- "turn these photos into a 30-second promo video with music and text"
- "creating short videos from photos or clips without editing software for content creators and small business owners"
### 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.
# AI Video Maker Free Online — Create and Export Videos Online
Send me your images or clips and describe the result you want. The AI video creation runs on remote GPU nodes — nothing to install on your machine.
A quick example: upload five product photos and a logo file, type "turn these photos into a 30-second promo video with music and text", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.
Worth noting: using fewer than 10 clips keeps render time under a minute.
## Matching Input to Actions
User prompts referencing ai video maker free online, 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` | `ai-video-maker-free-online` |
| `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.
### 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.
### 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
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 these photos into a 30-second promo video with music and text" — concrete instructions get better results.
Max file size is 500MB. Stick to MP4, MOV, JPG, PNG for the smoothest experience.
Export as MP4 for widest compatibility across social platforms.
## Common Workflows
**Quick edit**: Upload → "turn these photos into a 30-second promo video with music and text" → 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.
generate text prompts into AI generated videos with this sora-video-generation skill. Works with TXT, PNG, JPG, MP4 files up to 200MB. content creators use i...
---
name: sora-video-generation
version: "1.0.0"
displayName: "Sora Video Generation — Generate Videos From Text Prompts"
description: >
generate text prompts into AI generated videos with this sora-video-generation skill. Works with TXT, PNG, JPG, MP4 files up to 200MB. content creators use it for generating short videos from text descriptions — 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": "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 Video Generation — Generate Videos From Text Prompts
This tool takes your text prompts and runs AI video generation through a cloud rendering pipeline. You upload, describe what you want, and download the result.
Say you have a 10-word text prompt describing a scene and want to generate a 10-second video of a sunset over the ocean with waves crashing — the backend processes it in about 1-3 minutes and hands you a 1080p MP4.
Tip: shorter and more specific prompts tend to produce more accurate results.
## Matching Input to Actions
User prompts referencing sora video generation, 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.
Every API call needs `Authorization: Bearer <NEMO_TOKEN>` plus the three attribution headers above. If any header is missing, exports return 402.
Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `sora-video-generation`, `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`).
**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.
### 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 |
### 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 |
### 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.
**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)
```
## Common Workflows
**Quick edit**: Upload → "generate a 10-second video of a sunset over the ocean with waves crashing" → 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 waves crashing" — concrete instructions get better results.
Max file size is 200MB. Stick to TXT, PNG, JPG, MP4 for the smoothest experience.
Export as MP4 for widest compatibility.
Cloud-based ai-video-editing-online tool that handles editing raw footage into polished videos without desktop software. Upload MP4, MOV, AVI, WebM files (up...
---
name: ai-video-editing-online
version: "1.0.0"
displayName: "AI Video Editing Online — Edit and Export Videos Online"
description: >
Cloud-based ai-video-editing-online tool that handles editing raw footage into polished videos without desktop software. Upload MP4, MOV, AVI, WebM files (up to 500MB), describe what you need, and get 1080p MP4 output in 1-2 minutes. Built for content creators and marketers who work with raw video footage.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me your raw video footage and I'll handle the AI video editing. Or just describe what you're after.
**Try saying:**
- "edit a 2-minute unedited screen recording into a 1080p MP4"
- "trim the silences, add transitions, and export as a clean MP4"
- "editing raw footage into polished videos without desktop software for content creators and marketers"
### 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.
# AI Video Editing Online — Edit and Export Videos Online
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 "trim the silences, add transitions, 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 3 minutes process significantly faster.
## Matching Input to Actions
User prompts referencing ai video editing online, 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 `ai-video-editing-online`, `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`).
**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.
### 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 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)
```
## Tips and Tricks
The backend processes faster when you're specific. Instead of "make it look better", try "trim the silences, add transitions, 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 and devices.
## Common Workflows
**Quick edit**: Upload → "trim the silences, add transitions, 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.
content creators and marketers create raw video footage into polished MP4 videos using this skill. Accepts MP4, MOV, AVI, WebM up to 500MB, renders on cloud...
---
name: easy-ai-video
version: "1.0.0"
displayName: "Easy AI Video — Create and Export Finished Videos"
description: >
content creators and marketers create raw video footage into polished MP4 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 turning raw clips into finished videos without manual editing.
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 video creation. Or just tell me what you're thinking.
**Try saying:**
- "create my raw video footage"
- "export 1080p MP4"
- "trim the footage, add background music,"
### 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.
# Easy AI Video — Create and Export Finished Videos
Send me your raw video footage and describe the result you want. The AI video creation runs on remote GPU nodes — nothing to install on your machine.
A quick example: upload a 2-minute smartphone recording, type "trim the footage, add background music, and export as a shareable video", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.
Worth noting: shorter source clips under 3 minutes process significantly faster.
## Matching Input to Actions
User prompts referencing easy ai 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.
Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `easy-ai-video`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)
**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.
### 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
### 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.
**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)
```
## Common Workflows
**Quick edit**: Upload → "trim the footage, add background music, and export as a shareable 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.
## Tips and Tricks
The backend processes faster when you're specific. Instead of "make it look better", try "trim the footage, add background music, and export as a shareable video" — 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.
generate text prompts into AI-generated videos with this text-to-ai-video-generator-free skill. Works with TXT, DOCX, PDF, copied text files up to 500MB. mar...
---
name: text-to-ai-video-generator-free
version: "1.0.0"
displayName: "Text to AI Video Generator Free — Turn Text into AI Videos"
description: >
generate text prompts into AI-generated videos with this text-to-ai-video-generator-free skill. Works with TXT, DOCX, PDF, copied text files up to 500MB. marketers, content creators, students use it for generating videos from written text without recording footage — 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
> Send me your text prompts and I'll handle the AI video creation. Or just describe what you're after.
**Try saying:**
- "generate a 100-word product description into a 1080p MP4"
- "turn this text into a 30-second promotional video with visuals and music"
- "generating videos from written text without recording footage for marketers, content creators, students"
### 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 AI Video Generator Free — Turn Text into AI Videos
This tool takes your text prompts and runs AI video creation through a cloud rendering pipeline. You upload, describe what you want, and download the result.
Say you have a 100-word product description and want to turn this text into a 30-second promotional video with visuals and music — the backend processes it in about 1-2 minutes and hands you a 1080p MP4.
Tip: shorter, clearer prompts produce more accurate video results.
## Matching Input to Actions
User prompts referencing text to ai video generator 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.
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` | `text-to-ai-video-generator-free` |
| `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 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 |
### 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 |
## 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 promotional video with visuals and music" — concrete instructions get better results.
Max file size is 500MB. Stick to TXT, DOCX, PDF, copied text for the smoothest experience.
Export as MP4 for widest compatibility across social platforms.
## Common Workflows
**Quick edit**: Upload → "turn this text into a 30-second promotional video with visuals and music" → 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.
Cloud-based editor-online tool that handles editing videos directly in the browser without software. Upload MP4, MOV, AVI, WebM files (up to 500MB), describe...
---
name: editor-online
version: "1.0.0"
displayName: "Editor Online — Edit and Export Videos Online"
description: >
Cloud-based editor-online tool that handles editing videos directly in the browser without software. Upload MP4, MOV, AVI, WebM files (up to 500MB), describe what you need, and get 1080p MP4 output in 30-60 seconds. Built for content creators who work with video clips.
metadata: {"openclaw": {"emoji": "✂️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Got video clips 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 raw screen recording into a 1080p MP4"
- "trim the pauses, add transitions, and export as MP4"
- "editing videos directly in the browser without software for 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.
# Editor Online — Edit and Export Videos Online
Drop your video clips 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 raw screen recording, ask for trim the pauses, add transitions, and export as MP4, and about 30-60 seconds 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 3 minutes process significantly faster.
## Matching Input to Actions
User prompts referencing editor online, 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.
Three attribution headers are required on every request and must match this file's frontmatter:
| Header | Value |
|--------|-------|
| `X-Skill-Source` | `editor-online` |
| `X-Skill-Version` | frontmatter `version` |
| `X-Skill-Platform` | auto-detect: `clawhub` / `cursor` / `unknown` from install path |
**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.
### 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 |
### 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)
```
## Tips and Tricks
The backend processes faster when you're specific. Instead of "make it look better", try "trim the pauses, add transitions, and export as 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 and devices.
## Common Workflows
**Quick edit**: Upload → "trim the pauses, add transitions, and export as MP4" → 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.
marketers, content creators, small business owners create text or images into AI-generated videos using this skill. Accepts MP4, MOV, JPG, PNG up to 500MB, r...
---
name: video-erstellen-ki
version: "1.0.0"
displayName: "Video Erstellen KI — Create Videos with AI"
description: >
marketers, content creators, small business owners create text or images into AI-generated videos using this skill. Accepts MP4, MOV, JPG, PNG up to 500MB, renders on cloud GPUs at 1080p, and returns MP4 files in 1-2 minutes. Designed for generating videos from text prompts or images using AI.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---
## Getting Started
> Share your text or images and I'll get started on AI video creation. Or just tell me what you're thinking.
**Try saying:**
- "create my text or images"
- "export 1080p MP4"
- "Erstelle ein 30-Sekunden-Video aus meinem Text"
### 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 Erstellen KI — Create Videos with AI
Send me your text or images and describe the result you want. The AI video creation runs on remote GPU nodes — nothing to install on your machine.
A quick example: upload a short product description text and three product photos, type "Erstelle ein 30-Sekunden-Video aus meinem Text und diesen Bildern", and you'll get a 1080p MP4 back in roughly 1-2 minutes. All rendering happens server-side.
Worth noting: shorter scripts with clear sentences produce more accurate AI-generated scenes.
## Matching Input to Actions
User prompts referencing video erstellen ki, 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`: `video-erstellen-ki`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)
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 "Erstelle ein 30-Sekunden-Video aus meinem Text und diesen Bildern" — concrete instructions get better results.
Max file size is 500MB. Stick to MP4, MOV, JPG, PNG for the smoothest experience.
Export as MP4 for widest compatibility across social platforms and websites.
## Common Workflows
**Quick edit**: Upload → "Erstelle ein 30-Sekunden-Video aus meinem Text und diesen Bildern" → 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.
add video clips into music-backed videos with this add-music-to-video-free-online skill. Works with MP4, MOV, AVI, WebM files up to 500MB. content creators u...
---
name: add-music-to-video-free-online
version: "1.0.0"
displayName: "Add Music to Video Free Online — Add Music and Export Videos"
description: >
add video clips into music-backed videos with this add-music-to-video-free-online skill. Works with MP4, MOV, AVI, WebM files up to 500MB. content creators use it for adding background music to videos without editing software — processing takes 20-40 seconds on cloud GPUs and you get 1080p MP4 files.
metadata: {"openclaw": {"emoji": "🎵", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---
## Getting Started
> Share your video clips and I'll get started on music overlay addition. Or just tell me what you're thinking.
**Try saying:**
- "add my video clips"
- "export 1080p MP4"
- "add background music to my video"
### 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.
# Add Music to Video Free Online — Add Music and Export Videos
Drop your video clips in the chat and tell me what you need. I'll handle the music overlay addition on cloud GPUs — you don't need anything installed locally.
Here's a typical use: you send a a 60-second vacation clip in MP4 format, ask for add background music to my video and fade it out at the end, 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 clips under 2 minutes process significantly faster.
## Matching Input to Actions
User prompts referencing add music to video free online, 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.
Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.
Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `add-music-to-video-free-online`, `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`).
**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.
### 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
### 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.
**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)
```
## Common Workflows
**Quick edit**: Upload → "add background music to my video and fade it out at the end" → 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.
## Tips and Tricks
The backend processes faster when you're specific. Instead of "make it look better", try "add background music to my video and fade it out at the end" — 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.
Get 1080p MP4 files from your video clips or images using this instagram-reels-maker tool. It runs AI Reels creation on cloud GPUs, so your machine does zero...
---
name: instagram-reels-maker
version: "1.0.0"
displayName: "Instagram Reels Maker — Create and Export Reels Videos"
description: >
Get 1080p MP4 files from your video clips or images using this instagram-reels-maker tool. It runs AI Reels creation on cloud GPUs, so your machine does zero heavy lifting. Instagram creators and social media marketers can creating short vertical videos formatted for Instagram Reels in roughly 30-60 seconds — supports MP4, MOV, AVI, WebM.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Drop your video clips or images here and tell me what to do with it. Describe your idea if you don't have files yet.
**Try saying:**
- "create a 60-second vertical phone recording into a 1080p MP4"
- "cut to 30 seconds, add trending music and captions, format for Instagram Reels"
- "creating short vertical videos formatted for Instagram Reels for Instagram creators and social media 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.
# Instagram Reels Maker — What You Get
So here's how this works. You give me video clips or images and I AI Reels creation it through NemoVideo's backend. No local software, no plugins, no GPU on your end.
Tested it with a a 60-second vertical phone recording last week. Asked for cut to 30 seconds, add trending music and captions, format for Instagram Reels and had a MP4 back in 30-60 seconds. 1080p quality, decent file size.
vertical 9:16 video works best — no cropping needed for Reels. That's about it.
## 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 | ❌ |
## How It Works Internally
Everything happens on cloud infrastructure. Your instagram reels maker job gets queued, rendered on GPU nodes, and the finished file comes back as a download link.
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`: `instagram-reels-maker`
- `X-Skill-Version`: from frontmatter `version`
- `X-Skill-Platform`: detect from install path (`~/.clawhub/` → `clawhub`, `~/.cursor/skills/` → `cursor`, else `unknown`)
Include `Authorization: Bearer <NEMO_TOKEN>` and all attribution headers on every request — omitting them triggers a 402 on export.
**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)
```
### 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 |
### 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 |
## Quick Start Guide
1. Send your video clips or images (drag and drop works)
2. Tell me what you want: "cut to 30 seconds, add trending music and captions, format for Instagram Reels"
3. Wait 30-60 seconds for processing
4. Download your MP4 file
That's it. No account needed for your first 100 credits. Supports MP4, MOV, AVI, WebM.
## Common Workflows
**From scratch**: Describe what you want and the AI generates a draft. You refine from there.
**Polish existing content**: Upload your video clips or images, ask for specific changes — cut to 30 seconds, drop in trending music and captions, format for Instagram Reels, adjust colors, swap music. The backend handles rendering.
**Export ready**: Once you're happy, export at 1080p in MP4. File lands in your downloads.
## FAQ
**What resolution can I get?** Up to 1080p. Input quality matters though — garbage in, garbage out.
**Can I use this on my phone footage?** Yes. Vertical (9:16), horizontal (16:9), square — all work. Just upload and specify what you want.
**Credits?** 100 free to start. Most operations cost 1-5 credits depending on video length.
Just drop a text prompt and this skill runs it through both Seedance and Veo, returning 2 MP4 clips for direct comparison. It's built for teams deciding whic...
---
name: seedance-vs-veo
version: "1.0.0"
displayName: "Seedance vs Veo — Compare AI Video Generators Side by Side"
description: >
Just drop a text prompt and this skill runs it through both Seedance and Veo, returning 2 MP4 clips for direct comparison. It's built for teams deciding which model to standardize on before committing to API costs. Each output includes frame rate, resolution (up to 1080p), and generation time so you're comparing actual numbers, not impressions.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Paste a video prompt and I'll generate one MP4 from Seedance and one from Veo for side-by-side review. No prompt? Describe the scene you want to test.
**Try saying:**
- "Run 'a red sports car drifting on a rain-slicked road at night' through both Seedance and Veo and show me the MP4s"
- "Compare how Seedance and Veo handle the prompt 'a hummingbird hovering near a flower in slow motion' — I need to see motion quality differences"
- "Test this prompt on both models: 'a chef plating a dish in a modern kitchen' — include generation time and resolution in the results"
### 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.
# Run One Prompt, Get Two AI Videos Back
Type a single text prompt — say, "a cyclist riding through a foggy forest at dawn" — and the skill sends it to both Seedance and Veo simultaneously. You get 2 MP4 files, each labeled with model name, resolution, and generation time in seconds.
The comparison covers motion consistency, text adherence, and artifact frequency across a 3–8 second clip range. It doesn't rewrite your prompt for either model. What you write is what both models receive, keeping the test fair.
Results land in a side-by-side layout with metadata attached. You can re-run the same prompt 3 times to check output variance per model.
## Routing Prompts Between Models
Your input gets parsed for model-specific keywords — 'Seedance' routes to ByteDance's API endpoint, 'Veo' routes to Google DeepMind's endpoint, and anything ambiguous triggers a side-by-side comparison job that fires both simultaneously.
| 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 | ❌ |
## API Calls and GPU Queues
Each generation request hits the respective cloud rendering pipeline — Seedance queues on ByteDance's distributed GPU cluster while Veo processes through Google's TPU-backed infrastructure, so wait times differ based on each provider's current load. Response payloads return a signed video URL, generation latency in milliseconds, and the exact prompt echo used after any internal rewriting.
Headers are derived from this file's YAML frontmatter. `X-Skill-Source` is `seedance-vs-veo`, `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`).
**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.
### 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
## Quick Start Guide
Write a prompt between 10 and 80 words. Shorter prompts under 15 words tend to produce more variance between models, which makes the comparison more informative.
Submit it here — don't adjust phrasing for either model. The skill sends the identical string to both Seedance and Veo, then returns 2 labeled MP4 files, each capped at 1080p and between 3–8 seconds long.
Check the metadata block attached to each file. It lists model name, resolution, aspect ratio, and wall-clock generation time in seconds. Use those numbers when writing up your evaluation, not subjective impressions.
Re-run the same prompt 3 times if you need variance data. Output consistency differs between the two models, and a single run won't show that.
## Troubleshooting
If one MP4 returns blank or corrupted, the model timed out — generation cutoff is 90 seconds per model. Resubmit the prompt once before assuming a model-side failure.
Prompts over 150 characters sometimes cause Veo to truncate scene elements. Split long prompts into a core scene description (under 100 characters) plus a style note to keep both models working from equivalent inputs.
If both clips look identical, your prompt is likely too generic. Add at least 2 specific visual details — lighting condition, subject motion, camera angle — to create testable differences between the models' outputs.
Resolution mismatches (e.g., one file at 720p and one at 1080p) aren't a bug. The two models don't share a resolution default. Check the metadata block on each file rather than eyeballing clip size.
Turn your ideas into cinematic video clips with wan-ai, the powerful video generation model built for creators who need results fast. wan-ai transforms text...
---
name: wan-ai
version: "1.0.0"
displayName: "WAN AI Video Generator — Create Stunning AI Videos from Text & Images"
description: >
Turn your ideas into cinematic video clips with wan-ai, the powerful video generation model built for creators who need results fast. wan-ai transforms text prompts and still images into fluid, high-quality video sequences with remarkable motion consistency. Whether you're producing social content, concept visualizations, or product demos, this skill brings the full capability of WAN AI to your fingertips — no timeline editing, no rendering queues, just describe and generate.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me a text prompt or image and I'll generate a video clip using wan-ai right now. No idea yet? Just describe a scene, a mood, or a subject and I'll handle the rest.
**Try saying:**
- "Generate a video of a lone astronaut walking across a red desert planet at sunset, slow cinematic camera push-in, dust particles in the air"
- "Turn this product photo of a perfume bottle into a short video with soft light ripples and a rotating reveal effect"
- "Create a 4-second clip of a dense forest with morning fog drifting through the trees, birds flying up from the canopy, realistic lighting"
### 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.
# From Prompt to Video in Seconds
WAN AI is one of the most capable open-source video generation models available, and this skill puts it directly into your workflow. Whether you start with a text description or an existing image, wan-ai produces smooth, visually coherent video clips that hold up to real creative scrutiny — not just demo-reel magic.
Describe a scene, a mood, a camera movement, or a character in motion, and watch wan-ai interpret your intent into actual footage. The model handles temporal consistency exceptionally well, meaning objects and subjects don't randomly warp or flicker between frames the way earlier video AI models often did.
This skill is designed for content creators, marketers, indie filmmakers, game developers, and anyone who needs video assets without the overhead of a full production setup. Use it to prototype ideas quickly, generate B-roll, visualize scripts, or produce short-form social videos that actually look intentional and polished.
## Routing Text and Image Prompts
Each request is parsed to determine whether you're triggering a text-to-video generation, an image-to-video animation, or a style-transfer task, then dispatched to the appropriate WAN 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 | ❌ |
## WAN AI Cloud API Reference
WAN AI processes all diffusion jobs on distributed cloud inference nodes, meaning your prompts, motion parameters, and reference frames are handled server-side with no local GPU required. Generation latency depends on model variant — WAN 2.1 standard versus turbo — and current queue depth.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `wan-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 |
## Common Workflows
The most common way to use wan-ai is the text-to-video workflow: write a detailed scene description including subject, environment, lighting, camera behavior, and mood, then generate. The more specific your prompt, the more controlled the output — vague prompts produce interesting results but detailed prompts produce usable ones.
Image-to-video is equally powerful. Drop in a still photo or illustration and describe what motion should occur — a character turning their head, a product rotating, a landscape coming alive with wind and movement. WAN AI will animate it while preserving the visual identity of the source image.
For iterative work, generate a clip, review what worked, then refine the prompt and regenerate. Most creators treat the first output as a draft rather than a final product. Adjust motion intensity, camera style, or scene details between rounds to dial in exactly what you need.
## Use Cases
Social media creators use wan-ai to generate eye-catching video content for Reels, TikToks, and YouTube Shorts without filming anything. A strong text prompt can produce scroll-stopping visuals in under a minute.
Marketers and brand teams use it for concept visualization — showing stakeholders what a campaign might look like before committing to a full production budget. It's faster than storyboarding and more convincing than static mockups.
Game developers and concept artists use wan-ai to generate environment flythrough clips, character motion previews, and atmosphere tests for pitches or internal reviews.
Filmmakers use it for pre-visualization — generating rough versions of planned shots to communicate vision to crew, or to experiment with angles and staging before shoot day. It's also useful for generating abstract or VFX-heavy sequences that would be prohibitively expensive to produce practically.
## Quick Start Guide
To get your first video from wan-ai, start with a single clear scene description. Include: what the subject is, where it is, what it's doing, and what the camera is doing. Example: 'A red fox sitting in a snow-covered forest clearing, looking directly at camera, soft overcast light, slow zoom in, photorealistic.'
If you have a source image, attach it and describe the motion you want applied — keep motion descriptions grounded in physics for best results (things that could plausibly move in real life tend to animate more cleanly).
Avoid overly long prompts with conflicting instructions. If you want multiple scenes, generate them separately and combine in post. For stylistic control, include references to visual styles, film stocks, or directors whose aesthetic you want to evoke — wan-ai responds well to these kinds of qualitative cues.
Once you have a clip you like, use it as-is or bring it into your editing software for trimming, color grading, and sound design.
Tired of uploading your photos to video tools that demand an account, charge after 3 exports, or slap watermarks on everything? This image-to-video-ai-free-u...
---
name: image-to-video-ai-free-unlimited-without-login
version: "1.0.0"
displayName: "Image to Video AI Free Unlimited — Animate Photos Instantly Without Signing Up"
description: >
Tired of uploading your photos to video tools that demand an account, charge after 3 exports, or slap watermarks on everything? This image-to-video-ai-free-unlimited-without-login skill lets you animate still images into smooth, shareable videos with zero friction. No registration walls, no credit limits, no hidden paywalls. Perfect for content creators, social media managers, and anyone who wants to breathe life into product photos, portraits, or landscapes — right now, without the hassle.
metadata: {"openclaw": {"emoji": "🎞️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Drop your image here and I'll transform it into a smooth, shareable video instantly. No image yet? Just describe the scene and I'll guide you from there.
**Try saying:**
- "Here's a product photo of my sneakers — can you animate it into a short video with a slow zoom effect for Instagram?"
- "I have a landscape photo from my trip to Iceland. Turn it into a cinematic video clip with gentle motion and a widescreen feel."
- "Animate this portrait photo with a subtle Ken Burns effect and export it as a vertical 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.
# Turn Still Photos Into Videos — No Account Needed
Most image-to-video tools make you jump through hoops before you can do anything useful. Create an account. Verify your email. Pick a plan. Enter a credit card. By the time you've done all that, you've lost the creative momentum that made you want to make something in the first place.
This skill is built around a different philosophy: you bring the image, and we handle the rest — immediately. Whether you're working with a single product shot you want to animate for an Instagram story, a travel photo you want to turn into a cinematic reel, or a portrait you want to add subtle motion to, the process starts the moment you share your image.
The result is a fluid, ready-to-share video you can use across platforms without worrying about watermarks or export limits. Creators, small business owners, educators, and hobbyists all find this useful precisely because it removes every barrier between having an idea and seeing it move.
## Routing Your Animation Requests
Each photo-to-video request is parsed for motion style, duration, and output resolution, then dispatched to the nearest available inference node without requiring any account token or login credential.
| 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 Inference API Reference
The backend leverages a stateless diffusion pipeline that accepts raw image frames and returns interpolated video sequences in MP4 format, processing entirely in the cloud so no local GPU is needed. Sessions are ephemeral by design, meaning each animation job runs independently with no persistent user data stored between requests.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `image-to-video-ai-free-unlimited-without-login`
- `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
**Product marketing:** E-commerce sellers frequently use this skill to turn flat product photos into eye-catching video ads. A single well-lit product shot can become a looping video with a slow zoom or rotating pan — far more engaging on a product page or in a paid ad than a static image.
**Social media content batching:** Content creators often have dozens of photos from a shoot but limited time to produce video content. With image-to-video-ai-free-unlimited-without-login, you can run through a batch of images quickly, applying consistent motion styles to maintain a cohesive feed aesthetic without touching video editing software.
**Event and travel recaps:** Got 20 photos from a weekend trip or a company event? Animate each one with a subtle motion effect and string them together into a slideshow-style video recap that feels polished and intentional — without spending hours in a timeline editor.
**Portfolio and presentation upgrades:** Designers, photographers, and architects use animated image exports to make static portfolio pieces feel alive in pitch decks and client presentations.
## Quick Start Guide
Getting your first image-to-video result takes less than a minute. Start by sharing the image you want to animate — a JPEG, PNG, or WebP all work fine. Then tell the skill what kind of motion or style you're going for: a slow zoom, a pan across the scene, a parallax depth effect, or something more dynamic.
If you have a specific platform in mind — TikTok, Instagram Reels, YouTube Shorts, a website banner — mention it upfront. That way the output gets framed and sized correctly from the start, saving you from having to crop or reformat later.
No image on hand? You can describe a scene in plain language and get guidance on what kind of source image would work best, or use a placeholder to test the motion style before committing to a final photo. The whole point of image-to-video-ai-free-unlimited-without-login is that you can experiment freely without any account or usage pressure.
Breathe life into static images by turning them into fluid, cinematic video clips in seconds. This image-to-video-ai-generator skill takes your photos, illus...
---
name: image-to-video-ai-generator
version: "1.0.0"
displayName: "Image to Video AI Generator — Animate Still Photos Into Stunning Motion Videos"
description: >
Breathe life into static images by turning them into fluid, cinematic video clips in seconds. This image-to-video-ai-generator skill takes your photos, illustrations, or AI-generated art and transforms them into animated sequences with realistic motion, smooth transitions, and customizable pacing. Ideal for content creators, marketers, social media managers, and designers who want to produce eye-catching video content without complex editing software.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "control"}}
---
## Getting Started
> Welcome! I turn your still images into dynamic, motion-filled video clips using AI — no editing software needed. Drop an image and tell me the style of animation you want to get started!
**Try saying:**
- "Here's a product photo of my sneakers — can you animate it with a slow 360-degree rotation and a subtle zoom-in effect for an Instagram reel?"
- "I have a landscape painting I'd like turned into a video with a cinematic parallax drift and soft cloud movement in the background — about 6 seconds long."
- "Take this portrait photo and create a short looping video with a gentle breathing effect and a slow push-in toward the subject's face."
### 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 Still Frame to Moving Story — Instantly
Static images tell a moment. Videos tell a story. This skill bridges that gap by taking any image you provide — a product photo, a portrait, a landscape, an illustration — and generating a video clip that moves, breathes, and engages viewers in ways a flat image simply cannot.
Whether you're building a social media reel, animating a hero image for a landing page, or creating a slideshow that flows like a film, this tool handles the heavy lifting. You describe the motion style you want — a slow zoom, a parallax drift, a dramatic pan — and the AI interprets your image's content to produce natural-looking movement that fits the scene.
This skill is built for speed and creative flexibility. You don't need to storyboard, keyframe, or export from a timeline editor. Just bring your image and your vision, and within moments you'll have a video ready to share, embed, or build upon. It's the fastest path from a single photo to a scroll-stopping video clip.
## Motion Request Routing Logic
When you submit a still image for animation, your request is parsed for motion parameters — including frame duration, camera movement style, and interpolation intensity — then dispatched to the appropriate rendering pipeline based on resolution and complexity.
| 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 image-to-video synthesis runs on distributed GPU clusters via the animation backend, which handles optical flow estimation, temporal frame generation, and video encoding entirely in the cloud. Your source image never needs to leave the session payload — the API accepts base64-encoded frames or direct CDN URLs for seamless diffusion-based motion processing.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `image-to-video-ai-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 |
## Troubleshooting
If the generated video motion looks unnatural or jittery, the most common cause is an image with very low contrast between the subject and background. Try providing an image where the main subject is clearly separated from the background, or specify a simpler motion style like a slow zoom rather than a full parallax.
If the animation ignores part of your image — for example, not moving a sky element you expected to animate — try describing the specific region in your prompt more explicitly. Instead of 'make the clouds move,' try 'animate the upper third of the image with slow drifting cloud motion from left to right.'
For looping videos that feel seamless, request a motion style that returns to its starting position — such as a slow zoom that eases back out, or a drift that reverses gently. Abrupt-ending clips are harder to loop cleanly. If your output has an unexpected color shift or vignette, it may be related to the motion blur style applied — specify 'no vignette' or 'preserve original color grading' in your prompt to override default stylistic choices.
## Performance Notes
The quality of the generated video depends significantly on the input image. High-resolution images with clear subjects and well-defined edges produce the most convincing motion — the AI has more detail to work with when simulating depth and movement. Low-resolution or heavily compressed images may result in softer motion or visible artifacts around fine details like hair or foliage.
Complex motion requests on images with busy backgrounds — such as animating a crowd scene or a highly detailed illustration — may take longer to process and can occasionally produce inconsistent results in peripheral areas. For best output, start with a clear focal subject and a relatively uncluttered background.
Video length also affects processing time. Clips under 8 seconds generate quickly and maintain high fidelity. Longer sequences may require breaking the animation into segments for optimal quality. Portrait-oriented images (9:16) and square images (1:1) are natively supported for social media formats.
## Use Cases
This image-to-video-ai-generator skill fits naturally into a wide range of creative and professional workflows. E-commerce brands use it to animate product photos into short showcase clips for platforms like TikTok, Instagram Reels, and Pinterest Video Pins — dramatically increasing engagement compared to static listings.
Digital marketers use it to turn hero images and campaign visuals into motion ads without hiring a video production team. A single well-composed brand photo can become a 5-second bumper ad or a looping background video for a landing page.
Artists and illustrators use it to bring their work to life for portfolio showcases, NFT presentations, or social media promotion. A finished illustration animated with a subtle parallax effect feels entirely new without altering the original artwork.
Content creators building slideshows, memorial videos, travel recaps, or educational content use it to stitch animated image clips together into cohesive narrative videos that feel polished and intentional.
Turn your ideas, images, scripts, and raw clips into polished videos using free-ai-video-creator — a no-cost AI-powered video generation skill. Describe a co...
---
name: free-ai-video-creator
version: "1.0.0"
displayName: "Free AI Video Creator — Generate Stunning Videos Without Spending a Dime"
description: >
Turn your ideas, images, scripts, and raw clips into polished videos using free-ai-video-creator — a no-cost AI-powered video generation skill. Describe a concept, upload assets, or paste a script, and get back a structured, ready-to-publish video complete with scenes, captions, and pacing suggestions. Built for content creators, educators, small business owners, and social media managers who need professional-looking results without a production budget.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "control"}}
---
## Getting Started
> Welcome to Free AI Video Creator — where your ideas become fully structured, shareable videos without any budget or technical skills required. Tell me what kind of video you want to make and let's start building it right now!
**Try saying:**
- "I want to create a 60-second promotional video for my handmade candle business. I have a few product photos and want upbeat music. Can you write the script and scene breakdown?"
- "Turn this 800-word blog post about healthy meal prep into a YouTube video script with on-screen text suggestions and a hook for the first 5 seconds."
- "I need a short Instagram Reel explaining how to use my budgeting app. Make it punchy, under 30 seconds, with text overlays and a call-to-action at the end."
### 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.
# Create Real Videos From Just an Idea
Most people assume video production requires expensive software, a camera crew, or hours of editing experience. Free AI Video Creator flips that assumption entirely. You bring the concept — a product launch, a tutorial idea, a short story, a social media campaign — and this skill helps you shape it into a complete video structure with scenes, narration cues, on-screen text, and visual direction.
Whether you're a solo creator bootstrapping a YouTube channel, a teacher building lesson content, or a small business owner who needs a promotional clip without hiring a studio, this tool meets you where you are. Paste a blog post and turn it into a video script. Describe a brand story and get a shot-by-shot breakdown. Upload a rough concept and receive a production-ready outline.
The goal isn't just to save money — it's to remove the intimidation barrier entirely. You don't need to know video editing terminology, rendering formats, or production timelines. Just describe what you want, and Free AI Video Creator handles the creative heavy lifting.
## Routing Your Video Generation Requests
Each prompt you submit is parsed for scene descriptors, style tokens, and duration parameters before being dispatched to the optimal free-tier rendering node.
| 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
The backend leverages distributed GPU clusters running diffusion-based video synthesis pipelines, queuing your text-to-video jobs across free-allocation compute slots. Rendered output is temporarily cached in cloud storage and delivered via a signed URL valid for 24 hours.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `free-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
**The output feels too generic:** This usually happens when the initial prompt is vague. Instead of 'make a video about fitness,' try 'make a 45-second Instagram video targeting busy moms who want 10-minute home workouts, with an energetic tone and three specific exercise callouts.' The more context you provide about audience, tone, and platform, the sharper the result.
**The script is too long or too short:** Specify your target duration upfront. Mention '30-second video' or '3-minute YouTube explainer' in your request. If the output still feels off, ask for a revised version with tighter pacing or expanded scene descriptions.
**Scene suggestions don't match my footage:** If you're working with specific existing clips or images, describe them explicitly — 'I have a clip of a coffee shop interior, a barista pouring latte art, and a customer smiling.' Free AI Video Creator will write scenes around your actual assets rather than assuming what you have.
**Captions feel robotic:** Request a specific tone. Words like 'conversational,' 'punchy,' 'warm and friendly,' or 'professional but approachable' directly shape how captions and narration are written.
## Common Workflows
**From Text to Video:** The most popular workflow starts with existing content — a blog post, email newsletter, or product description. Paste it in, specify the target platform (YouTube, TikTok, Instagram), and Free AI Video Creator restructures it into a scene-by-scene video script with narration, visual cues, and caption timing.
**From Scratch with Just an Idea:** Not everyone has existing content. If you only have a vague concept — 'I want a video about why small businesses should use email marketing' — the skill will generate a full video outline including hook, body sections, and a closing call-to-action tailored to your audience.
**Social Media Repurposing:** Have a long-form video or podcast transcript? Drop it in and request a cut-down version optimized for a specific platform. Free AI Video Creator will identify the strongest moments, suggest where to trim, and rewrite captions for shorter attention spans.
**Brand Storytelling:** Describe your brand's origin, values, or a customer success story and receive a structured narrative video script complete with emotional beats, visual scene suggestions, and voiceover direction.
Bring any still photo to life with ai-talking-photo, the skill that syncs facial animation to audio and makes portraits speak, sing, or narrate. Upload a fac...
---
name: ai-talking-photo
version: "1.0.0"
displayName: "AI Talking Photo — Animate Still Images Into Lifelike Speaking Portraits"
description: >
Bring any still photo to life with ai-talking-photo, the skill that syncs facial animation to audio and makes portraits speak, sing, or narrate. Upload a face image and a voice clip — or just a script — and watch the photo animate with natural lip movements, blinking, and subtle expressions. Perfect for memorial videos, social content creators, educators, marketers, and anyone who wants to tell a story through a face rather than a talking-head video.
metadata: {"openclaw": {"emoji": "🗣️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---
## Getting Started
> Welcome! With AI Talking Photo, you can turn any portrait into a speaking, animated video in moments. Upload your photo and audio clip (or tell me what you'd like the subject to say) and let's bring it to life!
**Try saying:**
- "Animate this portrait with my audio"
- "Make my headshot say this script"
- "Create talking photo for social reel"
### 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.
# Make Any Photo Speak With One Upload
Static photos hold stories that never get told. AI Talking Photo changes that by turning a single still image into an animated, speaking portrait — no camera, no studio, no video shoot required. Whether it's a historical figure, a product mascot, a family member, or your own headshot, this skill breathes voice and movement into the image in seconds.
The process is straightforward: provide a clear face photo and either an audio file or a text script you want spoken. The skill analyzes the facial geometry, maps lip movements to the audio waveform, and generates a short video where the subject appears to genuinely speak. Subtle head motion, eye blinks, and micro-expressions are layered in to avoid the uncanny stiffness of early deepfake tools.
Creators use this for memorial tribute videos, branded spokesperson content, educational history lessons, social media reels, and interactive storytelling. If you can photograph a face, you can give it a voice — that's the core promise of AI Talking Photo.
## Routing Animate Portrait Requests
When a user submits a still image with a voice or script input, the skill parses the facial detection parameters and animation style preferences before dispatching the job to the appropriate talking photo pipeline endpoint.
| 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 | ❌ |
## Talking Photo API Reference
The cloud processing backend handles facial landmark mapping, lip-sync synthesis, and expression blending on remote GPU clusters, meaning heavy rendering never touches the local device. Completed animated portrait outputs are returned as video streams or downloadable clips once the synthesis job finalizes.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `ai-talking-photo`
- `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
The quality of your output is almost entirely determined by the quality of your input photo. Avoid images with heavy filters, strong side-lighting, or partial face occlusion — these confuse the facial landmark detection and produce jittery or misaligned lip movements. A neutral expression in the source photo gives the animation engine the most flexibility to map a wide range of speech sounds accurately.
Keep audio clips clean and free of background music during the lip-sync generation phase. If your final video needs music, add it as a separate layer after the talking photo is rendered. This prevents the model from misreading musical frequencies as speech phonemes.
For emotional impact — especially in memorial or tribute videos — choose audio that is paced naturally and not too fast. Rapid speech compresses lip movements and reduces the realism of the animation. A speaking rate of 120–150 words per minute tends to yield the most convincing results. Finally, always review the generated video before publishing; small manual trims at the start and end of the clip can remove any initialization frames where the face hasn't yet settled into the animation.
## Integration Guide
Getting started with AI Talking Photo requires just two inputs: a face image and an audio source. For best results, use a front-facing photo where the subject's mouth and eyes are clearly visible, unobstructed by hands, masks, or extreme angles. JPEG and PNG formats work well; aim for at least 512×512 pixels to preserve animation quality.
For audio, you can supply an MP3, WAV, or M4A file up to 60 seconds, or simply paste a text script and select a voice style — the skill will synthesize the speech internally before animating the photo. If you're embedding the output in a website or presentation, request the export in MP4 format with a transparent-background option for overlay use.
When building workflows — such as auto-generating spokesperson videos from a CMS or producing personalized video messages at scale — pass the image URL and script text as variables. The skill returns a video URL or file you can route directly into your delivery pipeline, email platform, or social scheduler.
Drop a still photo and watch it come alive — this skill uses ai-image-to-video-free technology to transform static images into fluid, cinematic video clips w...
---
name: ai-image-to-video-free
version: "1.0.0"
displayName: "AI Image to Video Free — Animate Still Photos Into Stunning Motion Clips"
description: >
Drop a still photo and watch it come alive — this skill uses ai-image-to-video-free technology to transform static images into fluid, cinematic video clips without any cost. Whether it's a portrait, landscape, product shot, or illustration, describe the motion you want and get a natural-looking animation in seconds. Built for creators, marketers, and storytellers who want professional results without a subscription.
metadata: {"openclaw": {"emoji": "🎞️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me a still image and describe the motion you want, and I'll generate a free AI-animated video clip from it — no image yet? Just describe a scene and I'll work from that.
**Try saying:**
- "Here's a photo of a mountain lake at sunset — can you animate it so the water ripples gently and the clouds drift slowly across the sky?"
- "I have a product photo of a sneaker on a white background. Make a short video where it slowly rotates 360 degrees to show all angles."
- "This is a portrait of a woman outdoors. Can you create a video where her hair moves slightly in the breeze and the background has a soft bokeh shimmer?"
### 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 Still Image Into a Living, Breathing Video
Still images capture a moment, but video tells a story. This skill bridges that gap by taking any photo you provide and generating smooth, realistic motion from it — panning across a landscape, animating a portrait's subtle expressions, or bringing product details into dynamic focus.
Using this tool, you describe the kind of movement or atmosphere you want, and the skill handles the rest. Want clouds drifting across a sunset photo? A model's hair swaying gently in the wind? A product rotating elegantly on a shelf? Just say so. The output is a short video clip ready to share on social media, embed in a presentation, or use in a larger project.
This is especially useful for content creators working on tight budgets, small business owners who want eye-catching visuals without hiring a production team, and social media managers who need fresh video content daily. No advanced editing knowledge required — just upload your image, describe your vision, and let the skill do the heavy lifting.
## Routing Your Animation Requests
When you submit a still photo for animation, your request is parsed for motion style, duration, and output resolution before being dispatched to the appropriate 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 Processing API Reference
All frame interpolation and temporal coherence rendering runs on distributed GPU clusters via the AI Image to Video Free backend, meaning your local device handles zero heavy lifting. Keyframe synthesis, motion vector estimation, and video encoding happen entirely in the cloud before the final clip is streamed back to you.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `ai-image-to-video-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 Common Issues
If the generated video doesn't match the motion you described, try being more specific in your prompt. Instead of 'make it move,' say 'slow pan from left to right with a slight zoom in on the subject.' The more directional and descriptive your instruction, the more accurate the output.
If the animation looks unnatural or glitchy around edges — particularly with portraits or objects that have complex outlines — try uploading a higher-resolution image with a clean background. Low-contrast or heavily compressed images can confuse the motion generation process.
For product images, make sure the subject is centered and well-lit. If you're animating a landscape and the horizon looks warped, specify that the camera movement should be horizontal only with no tilt. Iterating with small prompt adjustments usually resolves most visual artifacts within one or two tries.
## Use Cases for AI Image to Video Free
This skill shines across a surprisingly wide range of real-world scenarios. Social media managers use it to repurpose static brand photography into short Reels or TikToks without reshooting content. E-commerce sellers animate product images to show texture, dimension, and detail that flat photos miss — leading to higher engagement and click-through rates.
Photographers and digital artists use it to add a cinematic layer to their portfolios, turning a single compelling image into a looping video that feels alive. Educators and presenters drop historical photos or infographic images into this skill to create attention-grabbing slides that move.
Bloggers and newsletter writers who want to embed video without producing full shoots rely on this skill to generate quick, polished clips from existing image assets. Whether your goal is storytelling, marketing, or simply standing out in a crowded feed, animating your still photos is one of the fastest ways to upgrade your content output.
Tired of spending hours wrestling with complex video editing tools just to produce something that looks amateur? seedance-ai-video-maker takes your ideas, sc...
---
name: seedance-ai-video-maker
version: "1.0.0"
displayName: "Seedance AI Video Maker — Turn Ideas Into Stunning Videos in Minutes"
description: >
Tired of spending hours wrestling with complex video editing tools just to produce something that looks amateur? seedance-ai-video-maker takes your ideas, scripts, images, or prompts and transforms them into polished, dynamic videos without the steep learning curve. Generate cinematic scenes, animate still images, create product showcases, or build social-ready content — all through natural language. Built for creators, marketers, and storytellers who need results fast.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me a prompt, script, or image and I'll generate a compelling video using seedance-ai-video-maker. No footage? Just describe the vibe, subject, and style you want.
**Try saying:**
- "Create a 15-second product showcase video for a minimalist leather wallet, using warm lighting, slow zoom effects, and a luxury lifestyle feel."
- "Animate this product photo into a short looping video clip with a subtle parallax motion effect suitable for an Instagram ad."
- "Generate a cinematic travel video clip showing a sunrise over misty mountains with an emotional, sweeping atmosphere — no text, just visuals."
### 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.
# Create Cinematic Videos From Pure Imagination
seedance-ai-video-maker is a next-generation video creation skill that bridges the gap between your creative vision and a finished, shareable video. Whether you're a solo content creator, a small business owner, or a marketing professional, this skill lets you describe what you want and watch it come to life — no timeline scrubbing, no keyframe headaches, no rendering queues that eat up your afternoon.
With seedance-ai-video-maker, you can generate video clips from text prompts, animate still photos into fluid motion sequences, produce product demo videos from a simple description, or craft short-form social content tailored to platforms like TikTok, Instagram Reels, and YouTube Shorts. The AI understands context, mood, pacing, and visual style — so you spend less time explaining and more time publishing.
This skill is especially powerful for teams that need to move fast. Prototype a campaign video before committing to a full production budget. Test multiple visual styles in minutes. Repurpose a blog post into an engaging video summary. seedance-ai-video-maker removes the bottleneck between ideation and execution, making video creation genuinely accessible to anyone with a story to tell.
## Routing Your Video Prompts
Every request you send — whether it's a text-to-video prompt, image animation, or style transfer — gets routed to Seedance's generation pipeline based on the selected model tier and output resolution.
| 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 API Backend Reference
Seedance processes all video generation jobs on its distributed cloud inference nodes, handling frame interpolation, motion synthesis, and audio-visual sync entirely server-side. Your prompts and source assets are temporarily staged during rendering, then delivered as downloadable MP4 outputs once the job completes.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `seedance-ai-video-maker`
- `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 seedance-ai-video-maker
The more specific your prompt, the better your output. Instead of saying 'make a nature video,' try 'create a 10-second clip of golden-hour light filtering through a dense forest with slow camera movement and a peaceful tone.' Specificity in mood, camera motion, lighting, and subject gives the AI clearer creative direction.
When working with images, use high-resolution source files with a clear focal point. Cluttered or low-contrast images tend to produce less fluid animations. If you're building a multi-scene video, describe each scene separately and indicate transitions or pacing cues like 'cut to,' 'fade in,' or 'slow push forward.'
For social media content, always specify your target platform and aspect ratio upfront — vertical 9:16 for Reels and TikTok, square 1:1 for feed posts, or widescreen 16:9 for YouTube. This saves revision time and ensures the composition is optimized from the first generation.
## Use Cases That Shine With seedance-ai-video-maker
E-commerce brands use seedance-ai-video-maker to produce scroll-stopping product videos without hiring a videographer. A simple product image plus a style description can yield a professional-looking clip ready for paid social ads within minutes.
Content creators and influencers use it to rapidly prototype video concepts before filming, or to generate B-roll-style visuals that complement talking-head footage. It's also a go-to for filling content calendars during slow production weeks.
Agencies and freelancers leverage it to pitch clients with animated mockups and video concepts early in the creative process — setting expectations and winning approvals before any real production budget is spent. Educators and course creators use it to build engaging visual explainers from lesson outlines, turning dry text content into watchable, shareable video summaries.
## Tips and Tricks to Get More From Your Videos
Use style anchors in your prompts to guide the visual language. Phrases like 'shot on 35mm film,' 'drone footage aesthetic,' 'soft pastel color grade,' or 'high-contrast editorial look' dramatically shift the output without requiring any manual color work.
If you want consistent branding across multiple clips, describe your brand palette and visual identity in each prompt — for example, 'use deep navy and warm gold tones with clean sans-serif typography overlays.' Repetition of these cues across sessions helps maintain visual coherence.
Don't overlook the power of motion keywords. Words like 'drift,' 'orbit,' 'zoom burst,' 'handheld shake,' or 'locked-off static' give the AI specific camera behavior instructions. Combining motion style with subject and mood creates videos that feel intentional rather than randomly generated.
Tell me what you need and I'll transform your photos into polished, professional images in seconds. photo-editor-ai handles everything from background remova...
---
name: photo-editor-ai
version: "1.0.0"
displayName: "Photo Editor AI — Smart Image Editing, Retouching & Enhancement Tools"
description: >
Tell me what you need and I'll transform your photos into polished, professional images in seconds. photo-editor-ai handles everything from background removal and color correction to portrait retouching and creative filters. Whether you're a content creator fixing product shots, a photographer batch-editing portraits, or someone who just wants their vacation photos to look stunning — describe your edit and get precise, actionable results without touching complex software.
metadata: {"openclaw": {"emoji": "🖼️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "control"}}
---
## Getting Started
> Welcome to Photo Editor AI — your creative partner for retouching, enhancing, and transforming any image into exactly what you envisioned. Drop your photo description or editing request below and let's get started!
**Try saying:**
- "I have a portrait with harsh shadows under the eyes — how do I soften them without making the skin look fake?"
- "Remove the cluttered background from my product photo and replace it with a clean white studio look"
- "My sunset photo looks washed out and flat — help me make the colors vibrant and the sky dramatic without overdoing 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.
# Edit Smarter, Not Harder — AI Photo Magic
Photo editing used to mean hours hunched over sliders, wrestling with layer masks and color curves. Photo Editor AI changes that entirely. Describe what you want — sharper details, a different mood, a cleaner background — and get step-by-step guidance or direct edits that match your creative vision without the learning curve.
This skill is built for real editing scenarios: fixing overexposed shots from a birthday party, removing distracting objects from landscape photos, smoothing skin tones for a professional headshot, or giving an entire product catalog a consistent look. It understands context, not just commands.
Whether you're working with RAW files, JPEGs, or screenshots, Photo Editor AI adapts to your workflow. It suggests the right tools for your specific situation, explains what each adjustment does, and helps you develop an editing eye over time — so every session makes you a better editor, not just a faster one.
## Routing Edits to the Right Tool
Each request — whether it's a background removal, skin retouching, color grading, or upscaling — is parsed by intent and automatically dispatched to the appropriate processing pipeline within Photo Editor AI.
| 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
Photo Editor AI runs on a distributed cloud rendering backend that handles non-destructive edits, layer compositing, and AI model inference in real time. All image data is processed via encrypted API calls and returned as high-resolution output without storing originals beyond your active session.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `photo-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 |
## Performance Notes
Photo Editor AI performs best when you provide context about your end goal — print, web, social media, or e-commerce. Each destination has different resolution, color profile, and compression requirements that affect which edits to prioritize.
For high-resolution RAW files, describe your editing software (Lightroom, Photoshop, Capture One, GIMP) so recommendations use the correct tools and terminology. Generic advice rarely translates cleanly between applications.
Batch editing large catalogs works well when you establish a base preset or adjustment recipe first. Ask Photo Editor AI to help you define a consistent look for a shoot, then apply variations per image — this dramatically reduces per-photo editing time while keeping the series cohesive.
## Troubleshooting
If your edits aren't turning out as expected, the most common culprit is a vague description. Instead of saying 'make it look better,' try specifying: 'increase contrast slightly, warm up the shadows, and sharpen the subject's eyes.' The more precise your input, the more targeted the output.
For background removal issues — especially with fine details like hair or fur — mention the subject type upfront. Removing a person from a busy street scene requires different masking guidance than isolating a product on a shelf.
If color corrections look inconsistent across a batch of photos, check whether your source images have mixed white balance settings. Photo Editor AI can guide you through normalizing white balance before applying any global adjustments, which saves significant cleanup time later.
## Common Workflows
The most frequently used Photo Editor AI workflow is the portrait retouch pipeline: start with exposure and white balance correction, move to skin smoothing and blemish removal, then finish with eye enhancement and a subtle vignette. Describe your subject and lighting conditions upfront for the most accurate sequence.
For e-commerce product photography, the standard workflow covers background isolation, shadow creation or removal, color accuracy correction, and output sizing for platform-specific requirements like Amazon or Shopify.
Creative editing workflows — cinematic grades, film emulation, moody landscapes — benefit from describing a reference image or mood you're chasing. Mention color temperatures, contrast styles, and any specific era or aesthetic (e.g., '90s film grain, faded highlights') so Photo Editor AI can map that vision to concrete adjustments in your editing tool of choice.
Tell me what you need and I'll help you get the most out of your video-editing-app experience. Whether you're trimming raw footage, adding captions, syncing...
---
name: video-editing-app
version: "1.0.0"
displayName: "Video Editing App Assistant — Edit, Cut, and Polish Videos Like a Pro"
description: >
Tell me what you need and I'll help you get the most out of your video-editing-app experience. Whether you're trimming raw footage, adding captions, syncing audio, or exporting for social media, this skill walks you through every step with clear, practical guidance. Built for creators, marketers, educators, and hobbyists who want polished results without a steep learning curve. Ask about specific features, troubleshoot problems, or get step-by-step editing workflows tailored to your project.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Share your video editing question or describe your project and I'll give you a precise, step-by-step answer. No footage? Just tell me what you're trying to create.
**Try saying:**
- "I have a 10-minute raw interview clip and I need to cut it down to 2 minutes with smooth transitions — what's the best approach?"
- "How do I sync background music to match the beat of my video cuts in a typical video editing app timeline?"
- "My exported video looks pixelated on Instagram — what export settings should I use to keep quality high on mobile?"
### 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.
# Your Personal Guide to Faster, Smarter Video Editing
Editing video can feel overwhelming — timelines, codecs, color grading, audio mixing, export settings. This skill cuts through the noise and helps you focus on what actually matters for your specific project. Whether you're putting together a YouTube vlog, a product demo, a wedding highlight reel, or a short film, you'll get targeted advice that fits your workflow and your tools.
Instead of digging through forums or watching hour-long tutorials, just describe what you're trying to do and get a direct answer. Want to know how to remove background noise from a clip? How to create a smooth jump cut? How to add lower-third text overlays? This skill handles all of it with step-by-step clarity.
This isn't a generic video tips page. Every response is shaped around your actual video-editing-app scenario — the specific cut you're trying to make, the format you're exporting to, or the effect you're chasing. Think of it as having an experienced editor sitting next to you, ready to answer any question without judgment.
## Routing Cuts and Edit Requests
Every request you make — whether trimming a clip, applying a color grade, or exporting a timeline — gets parsed and routed to the matching editing function based on the action type and target asset.
| 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 Reference
All heavy lifting like transcoding, multi-track rendering, and effects processing runs through a distributed cloud backend, so your local device never bottlenecks the export queue. Render jobs are queued, prioritized by resolution and codec complexity, and results are streamed back as soon as the output file is ready.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `video-editing-app`
- `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
A typical social media workflow in a video-editing-app starts with importing and organizing footage into labeled bins — A-roll, B-roll, music, graphics. From there, build a rough cut on the timeline using only your best A-roll takes, then layer B-roll on top to cover cuts and add visual variety.
For YouTube content, the standard workflow is: rough cut → audio mix → color correction → graphics and titles → export review → final export. Doing these in order prevents you from having to redo work when something upstream changes.
When editing for clients, always work from a project duplicate and keep original media untouched. Deliver a low-resolution proxy preview first for feedback, then apply notes to the full-resolution timeline before final export. This saves hours of back-and-forth revision time.
## Tips and Tricks
One of the most underused features in any video-editing-app is the keyboard shortcut set. Learning even five shortcuts — play/pause, split clip, zoom timeline, undo, and export — can cut your editing time in half. Ask this skill for a shortcut cheat sheet tailored to your specific app.
When color grading, always correct before you grade. Use your app's scopes (waveform, vectorscope) to fix exposure and white balance first, then apply your creative look. Skipping correction leads to grades that fall apart across different screens.
For audio, normalize your dialogue tracks to around -12 dB before adding music. This gives you headroom and keeps voices clear. Use a low-pass filter on background music so it doesn't compete with speech in the midrange frequencies.
## Use Cases
Content creators use this skill to streamline their video-editing-app process — from figuring out the right aspect ratio for Reels versus TikTok versus YouTube Shorts, to automating repetitive tasks like adding intros and outros to every episode.
Small business owners rely on it to produce product demos and testimonial videos without hiring an editor. Getting guidance on basic color correction, clean cuts, and professional-looking title cards makes a huge difference in perceived brand quality.
Educators and trainers use video editing apps to produce course content, and this skill helps them add chapter markers, screen recording overlays, and closed captions efficiently. Whether you're recording a lecture or a software walkthrough, the workflow advice here is practical and project-specific.
Event videographers — weddings, corporate events, live performances — use it to handle multi-camera syncing, music licensing considerations, and highlight reel pacing that keeps audiences engaged from first frame to last.
Turn raw footage into polished, share-ready videos without installing a single app. This ai-video-editor-free-online skill lets you describe your editing goa...
---
name: ai-video-editor-free-online
version: "1.0.0"
displayName: "AI Video Editor Free Online — Edit, Trim & Enhance Videos Instantly Without Downloads"
description: >
Turn raw footage into polished, share-ready videos without installing a single app. This ai-video-editor-free-online skill lets you describe your editing goals in plain language — cut clips, add captions, adjust pacing, apply transitions, or reformat for different platforms — and get precise, actionable editing guidance or automated output instantly. Built for content creators, educators, small business owners, and social media managers who need professional results without a steep learning curve or a subscription paywall.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me your video link, footage description, or editing goal and I'll give you a step-by-step edit plan or direct output. No video yet? Just describe the style and content you want.
**Try saying:**
- "I have a 12-minute interview recording. Help me cut it down to a 90-second highlight reel focused on the key insights, and suggest where to add captions."
- "I filmed a product unboxing in landscape mode but I need it in vertical 9:16 format for Instagram Reels — how do I reframe and trim it to under 60 seconds?"
- "Can you help me add auto-generated subtitles, a logo watermark in the corner, and a fade-to-black ending to my tutorial video before I upload it to YouTube?"
### 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 Any Video with Just Your Words
Most people have footage sitting on their phones or drives that never gets used — because editing feels like too much work. This skill changes that. By combining AI-driven understanding of video structure with a free, browser-based approach, it lets you describe what you want and get results without touching a timeline or learning keyboard shortcuts.
Whether you're cutting a long interview down to the highlights, adding subtitles for accessibility, reformatting a landscape video into a vertical reel, or syncing clips to a beat — this skill walks you through each step or handles it directly. You don't need prior editing experience, and you don't need to pay for premium software.
This is designed for real-world use cases: a teacher turning a lecture recording into digestible segments, a small business owner creating a product demo from a phone video, or a creator repurposing a YouTube video into TikTok clips. Fast, free, and genuinely useful — that's the entire point.
## Routing Your Edit Requests
When you submit a trim, enhancement, or AI-generated effect, your request is parsed by the intent engine and dispatched to the appropriate cloud processing node based on operation type, file format, and current queue load.
| 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 backend leverages a distributed GPU pipeline to handle real-time video transcoding, frame interpolation, and AI upscaling entirely server-side — no local rendering required. Each API call passes your video stream through containerized processing workers that return a shareable output URL upon completion.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `ai-video-editor-free-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 |
## Performance Notes — What to Expect
This ai-video-editor-free-online skill works best when your input is clear and your goals are defined. Vague requests like 'make it better' will produce general suggestions, while specific requests like 'remove the first 45 seconds and add a jump cut at 2:10' will produce precise, actionable output.
For very long videos (over 30 minutes), consider working in segments rather than trying to process the entire file at once. Describe each section's purpose and the skill will help you build a coherent edit across all parts.
Browser-based processing means no large file uploads are required for planning and scripting your edit — you can get a full cut list, caption text, and transition notes before touching any export tool. When you're ready to render, the skill will point you to the right free online tool for your specific output format, whether that's a quick MP4 export, a GIF clip, or a captioned story video.
## Tips and Tricks for Getting the Best Edits
When describing your footage, be specific about what matters most — mention the platform you're editing for (YouTube, TikTok, Instagram), the target length, and the tone you want (punchy, calm, educational). The more context you give, the more precise the edit guidance will be.
If you're working with a long video, break it into goals: first ask for a cut list, then handle captions, then color or audio adjustments. Tackling one layer at a time produces cleaner results than trying to do everything at once.
For social media clips, always mention the aspect ratio upfront. A 1:1 square crop for LinkedIn behaves very differently than a 9:16 vertical for Reels, and knowing this early saves you from redoing work later. You can also ask for platform-specific pacing recommendations — TikTok audiences expect faster cuts than YouTube tutorial viewers, and this skill can help you match that rhythm without guesswork.
Turn raw footage into polished, professional-quality videos without spending hours in complex software. This skill helps you find and use the best-ai-video-e...
---
name: best-ai-video-editor
version: "1.0.0"
displayName: "Best AI Video Editor — Smart Editing Tools for Stunning Results"
description: >
Turn raw footage into polished, professional-quality videos without spending hours in complex software. This skill helps you find and use the best-ai-video-editor tools available — comparing features, recommending workflows, and guiding edits like cuts, captions, color grading, and transitions. Whether you're a content creator, marketer, or filmmaker, get tailored advice that matches your style, platform, and timeline.
metadata: {"openclaw": {"emoji": "🎬", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "greeting_v2"}}
---
## Getting Started
> Send me a description of your video project and I'll recommend the best AI video editor workflow, tools, and editing steps for it. No footage yet? Just describe the style or platform you're targeting.
**Try saying:**
- "I have a 10-minute raw interview recording and need to cut it down to a 90-second highlight reel for Instagram — what's the best AI video editor workflow for this?"
- "I'm making a product launch video for YouTube and want smooth transitions, captions, and a cinematic color grade — which AI editing tools should I use and in what order?"
- "I shoot travel content on my phone and want to repurpose horizontal footage into vertical Reels and TikToks automatically — what's the best AI video editor that handles this?"
### 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 AI Video Tools
Creating compelling video content used to require expensive software and years of practice. This skill changes that by acting as your personal guide to the best AI video editing tools and techniques available today — helping you cut through the noise and get straight to results that actually look great.
Whether you're editing a YouTube vlog, a branded social media reel, a product demo, or a short film, this skill walks you through the right approach for your specific project. You'll get concrete recommendations on which tools to use, how to structure your edit, and what features to lean on — from auto-captions and smart trimming to background removal and AI-powered color correction.
This isn't about generic advice. It's about understanding your footage, your audience, and your deadline — then helping you produce something you're genuinely proud of. Beginners get clear step-by-step guidance; experienced editors get faster workflows and sharper creative decisions.
## Smart Edit Request Routing
User prompts — whether for auto-cut, scene detection, color grading, or caption generation — are parsed by the intent engine and routed to the matching AI editing 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
All render jobs are offloaded to a distributed cloud backend that handles frame analysis, motion tracking, and generative fill without taxing your local machine. API calls return a job ID you can poll for progress, preview URLs, and final export links once transcoding completes.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `best-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 |
## Quick Start Guide
Getting started with the best AI video editor for your project takes just a few steps. First, identify your output goal: Is this for YouTube, TikTok, a client presentation, or personal use? Your platform determines aspect ratio, length, and caption requirements before you touch a single clip.
Next, choose your tool based on your skill level and budget. Beginners should start with CapCut or Veed.io — both offer free tiers with strong AI auto-edit, captioning, and resizing features. Intermediate creators benefit from Descript for dialogue-driven edits or Runway for visual effects. Advanced editors should explore Adobe Premiere with AI plugins or DaVinci Resolve's neural engine for color and audio.
Once you've picked your tool, import your raw footage, run the AI scene detection or auto-cut feature first, then layer in captions, transitions, and music. Always do a final manual review pass — AI gets you 80% there fast, but your creative eye closes the gap.
## Performance Notes
AI video editors vary significantly in how they handle different types of footage. Tools like Runway ML and CapCut AI perform best with well-lit, stable clips — shaky or low-light footage may produce inconsistent results with auto-edit features. If you're working with 4K files, check that your chosen editor supports your resolution before committing to a workflow, as some browser-based AI tools compress exports by default.
For long-form content (over 20 minutes), batch processing and scene detection tools will save you the most time. Editors like Descript or Adobe Premiere with Sensei AI handle transcription-based editing well at scale. For short-form social content under 60 seconds, CapCut, OpusClip, and Veed.io tend to produce the fastest turnaround with the least manual adjustment needed.
Always export a test clip before committing to a full render — AI color grading and audio enhancement can behave differently across monitors and playback platforms.
Tell me what you need and I'll help you edit, enhance, and transform your photos using AI-powered tools — completely free. This ai-photo-editor-free skill ha...
---
name: ai-photo-editor-free
version: "1.0.0"
displayName: "AI Photo Editor Free — Smart Editing Tools Without the Price Tag"
description: >
Tell me what you need and I'll help you edit, enhance, and transform your photos using AI-powered tools — completely free. This ai-photo-editor-free skill handles everything from background removal and color correction to portrait retouching and creative filters. Whether you're a hobbyist fixing vacation shots or a small business owner polishing product images, you get professional-quality results without subscriptions or software downloads.
metadata: {"openclaw": {"emoji": "🖼️", "requires": {"env": ["NEMO_TOKEN"], "configPaths": ["~/.config/nemovideo/"]}, "primaryEnv": "NEMO_TOKEN", "variant": "short_prompts"}}
---
## Getting Started
> Welcome to your free AI photo editing assistant — whether you want to retouch a portrait, fix lighting, or completely transform an image's mood, I'm ready to help. Share your photo or describe what you want to change, and let's get started!
**Try saying:**
- "Remove background from product photo"
- "Fix overexposed sunset image"
- "Make portrait look more professional"
### 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 Photos Like a Pro, Zero Cost Involved
Getting great-looking photos used to mean expensive software, steep learning curves, or paying a professional. This skill changes that equation entirely. With the AI Photo Editor Free skill, you describe what you want done to your image — and the AI figures out how to make it happen. Brighten a dark photo, swap out a cluttered background, smooth skin tones, sharpen blurry details, or apply a cinematic color grade. It's all on the table.
This skill is built for people who want results fast. You don't need to know what a histogram is or how layer masks work. Just tell the skill what the photo needs — 'make the sky more dramatic,' 'remove the person in the background,' 'make this look like a film photo from the 80s' — and it walks you through exactly what to do or does it directly.
From social media content creators to real estate photographers touching up listing images, this skill serves a wide range of everyday editing needs. It's the free photo editing assistant that actually understands what you're asking for.
## Routing Your Edit Requests
When you submit a photo editing prompt—whether it's background removal, AI upscaling, or smart retouching—ClawHub parses the intent and routes it to the matching AI Photo Editor Free endpoint best suited for that specific transformation.
| 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
AI Photo Editor Free runs on a distributed cloud inference backend that handles non-destructive edits, layer-aware adjustments, and generative fill operations without local GPU requirements. All image data is processed ephemerally through secured API calls, meaning your originals are never stored beyond the active editing session.
Skill attribution — read from this file's YAML frontmatter at runtime:
- `X-Skill-Source`: `ai-photo-editor-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
The AI Photo Editor Free skill performs best when you give it specific, descriptive instructions rather than vague requests. Instead of saying 'make it look better,' try 'increase contrast, warm up the shadows, and sharpen the subject.' The more detail you provide about the current problem and your desired outcome, the more precise and useful the editing guidance will be.
For background removal tasks, results are significantly stronger on images where the subject has clear edges and is well-separated from the background — think product shots on a table or portraits against a single-color wall. Heavily cluttered scenes with overlapping objects may require a few rounds of refinement.
Color correction requests work best when you describe both what looks wrong and what you're comparing it to. Mentioning a reference style ('like a bright Instagram food photo' or 'like a matte film negative') helps the skill calibrate suggestions to your actual creative vision rather than a technical default.
## Common Workflows
One of the most popular workflows with the AI Photo Editor Free skill is the product photo cleanup pipeline: start by removing the background, replace it with white or a brand-matching color, then adjust brightness and sharpness so the product pops cleanly. This workflow is used constantly by Etsy sellers, Amazon merchants, and small business owners who can't afford a studio shoot.
Portrait retouching is another high-traffic workflow. Users typically start with exposure and white balance correction, move into skin smoothing and blemish reduction, then finish with subtle sharpening on the eyes and lips. The skill can walk you through each of these stages or handle them as a single bundled request.
For content creators, the color grading workflow is a go-to: take a flat, neutral RAW-style image and apply a consistent mood across a batch of photos — whether that's a warm golden-hour aesthetic, a cool desaturated editorial look, or a punchy high-contrast style. Describe your brand's visual identity and the skill will translate that into actionable editing steps you can replicate across every image.