OpenClaw AI Video Editor

An autonomous agentic video editor. Send a sentence. Get a finished video. No timelines, no keyframes, no plugin chains.

Beta. The agent can make mistakes. Preview every output before publishing or sharing. For high-stakes or irreversible edits, pass requirePlanApproval: true so the agent stops after planning and waits for your approval before anything runs.

Contents

1. Quickstart — running in 60 seconds
2. What it does — say it, get it
3. Capability surface — the full toolset
4. Goals & briefs — from one line to a full creative brief
5. API reference — endpoints, request/response, streaming, async
6. Who it's for · vs. legacy editors · Safety · Media
7. Links & channels

Quickstart

The portable interface is the levea-mcp-server MCP server — one server, every MCP client (Claude Desktop, Claude Code, Cursor, Cline, OpenClaw, Hermes), one tool surface, one backend contract, so nothing drifts per platform.

1. Get an API key — sign up at studio.livecore.ai and generate an OpenClaw API key.

2. Add the MCP server — the same npx line works for every MCP client:

{
  "mcpServers": {
    "levea": {
      "command": "npx",
      "args": ["-y", "levea-mcp-server"],
      "env": {
        "LEVEA_API_URL": "https://api.livecore.ai",
        "LEVEA_API_KEY": "your-key-from-studio.livecore.ai"
      }
    }
  }
}

3. Use it — say to your AI: "Use the levea tool to generate 5 viral clips from this video, add captions, reframe vertical." The agent picks the tool, fills the prompt; the editor plans → executes → exports.

Per-client setup

This listing on ClawHub: openclaw plugins install clawhub:openclaw-ai-video-editor

Every client calls the same backend — the MCP server, this ClawHub listing, and every other surface share one tool contract.

Two hosts — don't confuse them

Env vars are LEVEA_API_URL / LEVEA_API_KEY.

Tools the AI sees

One editing entry point. Everything else is typed state-management and polling — so integrators can build full editing experiences through one API key instead of mixing JWT and MCP.

No edit shims (add_captions, generate_viral_clips, …) and no editor_execute escape hatch. The backend's planner is the specialist — fragmenting the editing surface encourages calling LLMs to second-guess the planner and lose multi-step intent. State-management tools (brand / project / asset / caption-template CRUD) aren't editing, so they don't fragment intent — they just give integrators typed access.

→ For agent-integration details (schemas, async semantics, error handling, plan approval), see AGENTS.md.

What it does

Say it in plain language; the agent plans and finishes the edit.

Capability surface

The full toolset behind the prompt. Everything below is reachable from natural language — mix and match in a single sentence.

🔍 Read & inspect

• Scene state — timeline / layer / scene structure, schema introspection
• Search — asset gallery (type, duration, name); transcript (keyword, semantic, timestamp)
• Vision — CV frame analysis (object, face, scene); on-screen text-region detection (locates chyrons / lower-thirds / burned-in captions so reframing avoids covering them)
• Intelligence — narrative peaks, speaker diarization, sentiment, pacing
• Jobs — async job status polling

✂️ Structural editing

• Layers — insert / update / replace / delete (video, audio, image, text, shape, solid, adjustment, group, light, vfx, visualizer, lottie)
• Timing — trim, split, retime (slow-mo 0.5×, fast-forward 2×, freeze-frame), reverse, stabilize
• Arrange — reposition, sequence, snap to transcript word boundaries
• Assemble — multi-cam sync + automatic angle switching, montage assembly (shot discovery + sequencing from source footage), slideshow generation, chapter markers, SRT import
• Safety — gap healing, audio normalize, duration reconcile (pre-export pass), multi-step undo / redo

🎬 Visual editing

• Color grade — brightness, contrast, saturation, hue, lift/gamma/gain, RGB curves, LUT / film-look presets, vignette, chromatic aberration
• VFX shaders — smoke, dust, fire, explosion, lightning, snow, glitch, scanlines, grain, glassmorphism, bokeh, lava, corrosion, portal
• Composite — chroma key, AI background removal (alpha matte), masking (luma / alpha / depth, with boolean multi-mask)
• Blend & opacity — 17 blend modes (multiply, screen, overlay, color dodge / burn, difference, hue / saturation / color / luminosity, additive) + per-layer & group opacity
• Shape & transform — clip shapes (circle, dome, star, hexagon, polygon), crop, 3D rotation / perspective, glow, shadow, gradient fills
• Lighting — up to 8 scene lights illuminating 3D-transformed layers
• Reframe & layout — caption-safe vertical reframe (9:16) + vertical montage, split screen (top/bottom, L/R, PiP, grid)
• Track — motion / face tracking with zoom-follow, branding overlays

📊 Motion graphics & data viz

30+ production-grade animated graphics:

• Data — transcript-driven charts (bar, line, pie), stat callouts, animated counters
• Lower-thirds & cards — lower-thirds, title / chapter cards
• Diagrams — flowcharts, timelines, geo callouts
• CTAs — animated subscribe / call-to-action buttons

💬 Captions & text

• Generate — auto-captions from the transcript
• Style — built-in templates, or an AI director that picks/generates one at runtime
• Animate — per-word animations (typewriter, slide, fade, scale, rotate, bounce, flip, swing, elastic, blur, glitch, wave — each with a matching exit)
• Typography — crisp scalable glyphs (MSDF), stroke / outline, drop shadow, gradient fill, background pill / box, per-word karaoke fill + underline
• Shape — curved text paths (circle, wave, custom SVG), Lottie playback control

🎵 Audio

• Clean up — remove silences, breaths, filler words; word-level mute/cut
• Mix — auto-duck (sidechain music vs voice), loudness (LUFS) normalize + true-peak limiting, denoise, crossfade, EQ presets (bass-boost, vocal-clarity, warm, bright), stem separation
• Generate — SFX, music (mood/genre/BPM), voiceover (TTS or cloned voice)
• Sync — external master audio alignment (timecode / explicit offset)
• Visualize — waveforms (bars, wave, circular)

🔒 Privacy & cleanup

• Faces — blur all faces or background-only
• Regions — privacy redaction (blur / cover)
• Language — profanity cleanup (mute / bleep)
• Layout — safe-zone repair

✨ Async generation

• Video — AI video / B-roll (duration + aspect)
• Images — AI images (single or batch at timestamps), generative image edit, auto-thumbnail extraction
• Audio — AI music (prompt + duration + mood + genre + BPM), AI voiceover (TTS or cloned voice library)

🚀 High-level presets

• Viral — vertical + captions + silence removal + tracking + word emphasis
• Cinematic director — dynamic zooms + cinematic grade + mood camera moves
• Emphasis system — keyword detection + coordinated scaling / glow / pulse
• Pacing optimizer — filler + silence + low-energy removal for retention

📦 Export

• MP4 — single file (resolution / codec / quality tier)
• Viral-clip batch — auto-segmented short-form, packaged as a ZIP
• Multi-platform pack — TikTok + Reels + Shorts + YouTube + Instagram in one pass

🗺️ Roadmap

• Content-aware object removal (AI mask + inpaint)
• Reading on-screen text content (OCR recognition — region detection ships today)

Goals & briefs

autonomous_edit accepts anything from a five-word command to a five-hundred-word creative brief.

1. Direct commands — a single edit, single result. The What it does examples above are all direct commands.

2. Open-ended goals — hand the agent a goal instead of a command; it inspects the asset, then proposes a plan:

"Watch this and tell me how to make it more engaging for TikTok"
"Look at the first 30 seconds and suggest 3 ways to hook the viewer"
"Review this footage and propose edits to tighten the pacing"

Pair these with requirePlanApproval: true for propose-only mode — the agent stops after planning and waits for your approval (see Plan approval).

3. Full creative briefs — multi-step orchestrations executed end-to-end. The agent decomposes the brief into a DAG of canonical actions, plans the order, executes through safety gates, verifies each step, and exports every requested format. Use SSE to watch each step land in real time.

Transform this video into a viral social media documentary. Start by trimming the first 3 seconds and last 5 seconds to remove dead air. Apply a cinematic color grade with warm tones and high contrast. Generate auto-captions with bold yellow text and black outline, positioned bottom center. Add a dynamic zoom-in on the main subject during the first 10 seconds. Insert 3 contextual b-roll clips where the speaker mentions visual concepts. Apply face tracking to keep the subject centered when converting to vertical 9:16 for TikTok and Reels. Add an upbeat background track that matches the energy, with auto-ducking when the speaker talks. Remove all silence gaps longer than 0.5 seconds. Apply a subtle vignette. Add my logo watermark top-right at 80% opacity. Generate a custom thumbnail from the most expressive frame with bold "MUST WATCH" text. Create an animated subscribe button that appears at 5 seconds and pulses. Add whoosh SFX for transitions. Apply noise reduction. Split at 30 seconds to insert a 2-second transition. Add animated counter overlays for key statistics. Blur background faces for privacy. Export in 1080p for YouTube plus optimized TikTok, Reels, and Shorts versions with platform-specific aspect ratios.

No timeline UI, no per-step API calls, no glue code on your side.

API reference

Base URL: {LEVEA_API_URL} (production: https://api.livecore.ai). Auth on every request:

Authorization: Bearer {LEVEA_API_KEY}

All paths are under /api/v1/misc/openclaw.

Each management group above is also exposed as a typed MCP tool (see Tools the AI sees).

LEVEA_API_URL is the bare host https://api.livecore.ai — not a full path, not studio.livecore.ai, and not the in-product /api/v1/misc/editor/ route.

Request

Every edit goes through one tool — autonomous_edit. Pass a natural-language description; the agent plans, executes, verifies, and exports. No tool list to memorize, no structured params to learn.

curl -sS -X POST "$LEVEA_API_URL/api/v1/misc/openclaw/v1/execute" \
  -H "Authorization: Bearer $LEVEA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "autonomous_edit",
    "params": {
      "prompt": "Make this a TikTok-ready viral clip: vertical reframe, bold captions, remove silences, motion-track the speaker, and export."
    },
    "project_id": "my-project"
  }'

prompt is the only required field. Everything else is optional:

Response

{
  "type": "success | partial_success",
  "tool": "autonomous_edit",
  "success": true,
  "partial": false,
  "status": "completed | failed | awaiting_approval",
  "scene": { },
  "reply": "Human-readable summary of what changed",
  "message": "Short status message",
  "videoUrl": "https://.../output.mp4",
  "jobId": "12345",
  "viral_clips": [ ],
  "zip_url": "https://.../clips.zip",
  "activeTasks": [ ],
  "pendingAsyncJobs": [ ],
  "verificationPassed": true,
  "verificationIssues": [],
  "quality": {
    "score": 0.94,
    "stepsTotal": 7,
    "stepsFailed": 0,
    "hasExportedMedia": true,
    "mediaReachable": true
  },
  "processingTime": 12.3,
  "workingMemory": { }
}

jobId is the numeric task_id (a string of digits), not a task_-prefixed value. quality is a calibrated post-run score block; partial is the top-level partial-success flag (mirrors type: "partial_success").

SSE streaming

Set Accept: text/event-stream or ?stream=true. Notable event types:

Async job lifecycle

Generation actions return immediately with a jobId. Poll until terminal:

JOB_ID=$(jq -r '.jobId // .activeTasks[0].intent.job_id' /tmp/result.json)
while true; do
  STATUS=$(curl -sS "$LEVEA_API_URL/api/v1/misc/openclaw/v1/jobs/$JOB_ID" \
    -H "Authorization: Bearer $LEVEA_API_KEY" | jq -r '.status')
  echo "Status: $STATUS"
  case "$STATUS" in completed|succeeded|failed|error|cancelled) break;; esac
  sleep 5
done

curl -sS "$LEVEA_API_URL/api/v1/misc/openclaw/v1/jobs/$JOB_ID" \
  -H "Authorization: Bearer $LEVEA_API_KEY" | jq '.result'

Auto-export

After any mutating tool call that changed the scene (including partial successes), if no export is already queued the route auto-fires one synchronously — so the response carries a real videoUrl. Read-only and conversational autonomous_edit calls do not trigger auto-export.

Plan approval

Pass requirePlanApproval: true to make the agent stop after planning. It returns status: "awaiting_approval" + populated workingMemory. Resume by sending the same workingMemory with an approval prompt (yes, approve, go, do it, confirm).

Who it's for

vs. legacy editors

This isn't an editor with AI features bolted on — it's an autonomous agent that finishes the edit for you.

Safety & limits

• Beta — outputs can be wrong. Preview every result before sharing. For irreversible workflows, pass requirePlanApproval: true to inspect and approve the plan first.
• API-key authentication on every request.
• Destructive actions (mass deletes, clears) require explicit confirmation params.
• Output is verified after execution; auto-repairs on failure.
• Concurrent identical requests are deduplicated server-side.
• Rate-limited per API key. Read-only ~1–3s · structural edits ~3–10s · async generation 30s–5min per artifact · viral-clip / multi-platform exports several minutes.

Supported media

Links & channels

Versions aren't pinned here — npx -y levea-mcp-server and the ClawHub listing always pull the latest, and the linked npm / ClawHub pages show the current version. You never need a specific number.

Support — setup help, integration questions, or issue reports: brajendrak00068@gmail.com

License — MIT