Skip to main content
Glama

Levea — Prompt-First AI Video Editor (MCP Server & Cloud Production Studio)

Prompt-to-video editing without manual timelines. Describe the edit in plain language; Levea plans it, edits a real multi-layer project, checks the result on the rendered frames, and exports the MP4. An open-source MCP client connects your AI agent (Claude Desktop, Claude Code, Cursor, Cline, Gemini CLI, OpenClaw, Hermes, ChatGPT) to our cloud GPU video editor: frame-accurate cuts, 280+ caption templates, 2D and 3D motion graphics reviewed by an AI critic, a licensed music and sound-effects library, voiceovers, and active-speaker reframing, with nothing heavy running on your machine.

npm MCP Registry ClawHub Plugin ClawHub Skill License: MIT


🚀 30-Second Quick Connect (Claude · ChatGPT · Claude Code · Cursor · OpenClaw · Hermes)

Where You Work

How to Connect Levea (Copy & Paste)

Claude.ai (Web / Desktop / Mobile)

Settings → Connectors → Add custom connector → Paste https://api.livecore.ai/api/v1/misc/mcp → Sign in with OAuth 2.1 (zero install).

ChatGPT (Web / Desktop Connectors)

Settings → Connectors → Create → MCP Server URL: https://api.livecore.ai/api/v1/misc/mcp (OAuth 2.1 + PKCE automatic). Or use chatgpt/openapi.json for Custom GPT Actions.

Claude Code (CLI / IDE)

Run /plugin marketplace add brajendrak00068/agentic-ai-video-production then /plugin install levea-video-editor (or claude mcp add --transport http levea https://api.livecore.ai/api/v1/misc/mcp).

Claude Desktop (1-Click .mcpb)

Download levea-mcp-server-0.7.1.mcpb and double-click to install in Claude Desktop.

Cursor / Windsurf / Cline

Add remote MCP https://api.livecore.ai/api/v1/misc/mcp (OAuth 2.1) or stdio npx -y levea-mcp-server with LEVEA_API_KEY from livecore.ai.

OpenClaw / ClawHub

openclaw plugins install clawhub:openclaw-ai-video-editor + clawhub install levea-ai-video-editor

NousResearch Hermes

hermes plugins install levea-video-editor && hermes plugins enable levea-video-editor

Agent Skills CLI (npx skills)

npx skills add brajendrak00068/agentic-ai-video-production

Why Use Levea Inside Claude Code / Cursor Instead of Local ffmpeg, Python, or Standalone HTML/DOM Video Tools?

In Claude Code, an agent can run local ffmpeg scripts or render standalone HTML/CSS animations in headless Chrome. Here is the practical difference — and why Levea is a superset (Levea runs full 2D/3D motion graphics inside its cloud GPU NLE timeline alongside computer vision and GPU video compositing):

Capability

Raw ffmpeg / MoviePy (Local CLI)

Standalone HTML/DOM Video Tools (Local Headless Chrome)

Levea MCP (livecore.ai Cloud GPU NLE + Motion Graphics)

Best For

Simple container remuxing or fixed-coordinate trims

Standalone code-driven motion graphics, HTML decks & website promos

Real footage NLE editing + motion graphics + podcasts + viral shorts + VFX

9:16 Active-Speaker Reframe

❌ Crops dead-center (crop=ih*9/16:ih), slicing speakers' faces in half

❌ DOM/CSS has no per-frame face or mouth landmark detector

✅ 68-point face & active-mouth tracking per frame + auto 2-up split-screen

3D Camera Tracking, Hand Tracking & Rotoscoping

❌ None

❌ Browser DOM cannot solve 3D camera motion or track hands/masks on video

✅ Monocular 3D camera solve, hand palm tracking, 2D region tracker, optical-flow warp stabilizer & AI alpha mattes

Green Screen & GPU VFX Compositing

❌ Basic chromakey leaves green halos; no 3D LUT/bokeh pipeline

❌ Headless Chrome captures DOM screenshots; no native video shader pipeline

✅ Cloud GPU compositor: Keylight-grade despilled keying, depth bokeh, 328 GPU VFX presets, 170+ transitions, .cube 3D LUTs

Kinetic Captions (280+ Templates)

❌ Flat static .srt / drawtext that collides with faces

⚠️ Must hand-code CSS per video; no automatic face/chin collision solver

✅ 280+ GPU kinetic templates (hormozi, mrbeast, karaoke) + measured face/chin & TikTok safe-zone solver

Multicam Podcast & Broadcast Audio

❌ silencedetect clips word tails; no multicam speaker switching

❌ Not an audio/multicam NLE; <video> tags in headless Chrome desync on long multi-track cuts

✅ Waveform multicam sync, ASR word-boundary cuts, filler removal, -18 LUFS auto-ducking, stem separation & lip-synced dubbing

Motion Graphics

❌ None

✅ Full HTML/CSS/GSAP/Three.js compositions

✅ Included natively — 2D/3D motion graphics plus After Effects shape layers (Trim Paths, Repeaters), composited over real tracked footage

Human Final Polish (<100ms GUI)

❌ Must re-run 5-min ffmpeg command to nudge one word

❌ Must edit HTML/CSS code and re-render headless Chrome frames

✅ 1-Click livecore.ai Web Studio: scrub at 60fps, drag captions, or swap templates in <100ms without re-rendering

Where It Runs

Laptop only (CPU-heavy)

Laptop only (requires Node, Chromium, ffmpeg, GBs of local disk)

Everywhere: Claude.ai Web/Mobile, ChatGPT, Claude Code, Cursor, Grok Bot, OpenClaw, Hermes (100% cloud GPU)


Related MCP server: ViralSpin MCP

⚡ The Levea Philosophy: Prompt-to-Project

Unlike traditional one-shot AI video generators that output locked, un-editable pixels, Levea maintains a fully structured, multi-layer editable project and timeline containing video tracks, audio, text, masks, motion graphics, and brand kits.

  • Editable Multi-Track Projects: Every edit updates a persistent multi-layer timeline with full undo/redo revision history, so you can refine any cut, caption, or layer in follow-up prompts or open the project in the web studio.

  • Cloud GPU Rendering & Vision: Heavy computation (GPU rendering, transcription, active-speaker face tracking, 2D/3D motion graphics, and audio mastering) runs on our remote cloud GPU cluster. You get 4K and vertical reel exports without melting your local laptop CPU or installing CUDA.

  • Open-Source Client, Hosted Engine: The client-side MCP server wrapper (levea-mcp-server), OpenClaw plugins, and skills are open-source (MIT). They connect to our hosted video production engine with OAuth 2.1 sign-in or an API key. Create a free account at livecore.ai.


🌐 Where to Use Levea (Every Client, Same Project)

Every Levea client connects to the same cloud editor and shares the same project workspace (edit contract). Start an edit from Claude, Cursor, ChatGPT, OpenClaw, Hermes, or Telegram, and open the exact same project in the web studio:

Client / Channel

How to Use

Web studio

livecore.ai

Telegram bot

@Levea_editing_bot — edit from your phone and link to your Levea account

Levea HTTP API

API reference (https://api.livecore.ai/api/v1/misc/openclaw/v1/*)

levea-mcp-server (stdio)

npm · MCP Registry (npx -y levea-mcp-server)

Hosted MCP (zero install)

https://api.livecore.ai/api/v1/misc/mcp — OAuth 2.1 sign-in or Authorization: Bearer <key>

Claude Code plugin

claude-plugin/ — /plugin install levea-video-editor --marketplace brajendrak00068/agentic-ai-video-production

Claude.ai connector

Add https://api.livecore.ai/api/v1/misc/mcp as a custom connector (OAuth 2.1)

ChatGPT app & Custom GPT

Connect https://api.livecore.ai/api/v1/misc/mcp (chatgpt-plugin/) or use chatgpt/ (OpenAPI spec + instructions)

Cursor plugin

.cursor-plugin/marketplace.json — add this repo as a plugin marketplace in Cursor

Gemini CLI extension

gemini-extension.json — gemini extensions install https://github.com/brajendrak00068/agentic-ai-video-production

Grok Bot

Add https://api.livecore.ai/api/v1/misc/mcp by URL — see Use inside Grok Bot

Mistral Le Chat

Add https://api.livecore.ai/api/v1/misc/mcp as a Le Chat connector

OpenClaw plugin

ClawHub (openclaw plugins install clawhub:openclaw-ai-video-editor)

Hermes plugin

hermes-plugin/ (Python) · hermes-levea/ (MCP bundle)


🛠️ Dual-Path Quickstart (Get Started in 60 Seconds)

Whether you are an AI developer looking to integrate automated editing into your agent loops, or a content creator building an automated faceless channel, Levea has a native path for you.

🟣 Claude Code plugin (one command)

Install Levea as a Claude Code plugin. It bundles the hosted Levea MCP server (OAuth sign-in, nothing to run locally) and a Levea editing skill:

/plugin install levea-video-editor --marketplace brajendrak00068/agentic-ai-video-production

Or from your shell:

claude plugin marketplace add brajendrak00068/agentic-ai-video-production
claude plugin install levea-video-editor@levea

On first use, run /mcp, select levea, and sign in to your Levea account in the browser. Then describe the edit, for example: "Cut a 30-second vertical clip from https://example.com/talk.mp4 with word-by-word captions and export an MP4."

🌐 Hosted MCP (no install)

Any MCP client that supports remote servers can connect to the hosted endpoint directly:

https://api.livecore.ai/api/v1/misc/mcp

It speaks Streamable HTTP and signs you in with OAuth 2.1 (the client opens a browser to your Levea account). Clients that cannot do OAuth can send Authorization: Bearer <your Levea API key> instead.

Two hosts bundle this hosted server for one-step installs:

  • Gemini CLI extension — this repo is a Gemini extension (gemini-extension.json):

    gemini extensions install https://github.com/brajendrak00068/agentic-ai-video-production
  • Cursor plugin — add this repo as a plugin marketplace in Cursor (it reads .cursor-plugin/marketplace.json), then install levea-video-editor.

🤖 Use inside Grok Bot

Grok Bot can add an MCP server by URL, and the hosted server speaks the exact contract it expects (Streamable HTTP, OAuth 2.1 with RFC 7591 dynamic client registration). Tell your Bot:

"Add the Levea MCP server: https://api.livecore.ai/api/v1/misc/mcp"

(or use Connect apps → add an MCP server by URL). A browser opens to sign in to your Levea account — then every Levea tool (autonomous_edit, queue_edit, direct canonical actions, job polling, caption templates, brand kits, projects, assets) is available to that Bot, and edits land in the same projects you see in the web studio. Clients that cannot do OAuth can use Authorization: Bearer <your Levea API key> instead.

🧑‍💻 Path A: For Developers & AI Engineers (The MCP Route)

Expose Levea as a client-side Model Context Protocol (MCP) server stdio wrapper (levea-mcp-server) in your favorite AI editors (Cursor, Cline, Windsurf, or Claude Desktop).

1. Get an API Key

Sign up at livecore.ai and generate a Levea API key.

2. Register the MCP Server

Add the following configuration block to your editor's MCP settings:

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

Note: LEVEA_API_URL should point to the bare host domain https://api.livecore.ai. The client-side wrapper handles endpoint appending automatically.

Client

Setup Commands / Instructions

Cursor & Windsurf

Go to Settings -> Features -> MCP -> Add New MCP Server. Set type to command and insert the config above.

Cline

Open settings, scroll to MCP, and add the config to the Cline MCP settings file.

Claude Code

Run: claude mcp add levea -e LEVEA_API_URL=https://api.livecore.ai -e LEVEA_API_KEY=... -- npx -y levea-mcp-server

Claude Desktop

Add the server block to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows).

Hermes

Native plugin: hermes-plugin/ (hermes plugins install levea-video-editor && hermes plugins enable levea-video-editor). Or register levea-mcp-server as an MCP server using the bundled hermes-levea/mcp.json.

OpenClaw

Install via ClawHub: openclaw plugins install clawhub:openclaw-ai-video-editor or add via CLI openclaw mcp add levea --command "npx -y levea-mcp-server" --env LEVEA_API_URL=https://api.livecore.ai --env LEVEA_API_KEY=....


🎨 Path B: For Creators & Marketers (The OpenClaw Route)

Deploy Levea as an autonomous editing agent directly inside the OpenClaw workspace.

  1. Install the Plugin: Search for openclaw-ai-video-editor on ClawHub and install it. It adds the edit, queue, discovery, and status tools.

  2. Install the Skill: Add levea-ai-video-editor from ClawHub Skills so your agent knows when and how to call the tools.

  3. Run your first edit:

    "Review my vertical video, remove the opening silence, auto-apply Hormozi-style captions with highlighted keywords, add subtle background music, and export the Reels-ready MP4."


🧩 How Skills Work & How to Use Your Own Custom Skills

Levea is built around Skills (SKILL.md) at three levels — so your agent always edits with professional craft rules, and you can define your own reusable editing playbooks:

1. 100+ Built-In Production Craft Skills (On-Demand via MCP)

Levea ships with 100+ production craft playbooks covering short-form hooks, podcast repurposing, documentary montage, color grading & LUT finishing, kinetic caption typography, 2D/3D motion graphics, VFX keying & optics, broadcast audio mastering (-18 LUFS ducking), and lip-synced dubbing.

  • In Mode A (autonomous_edit): Levea automatically selects and applies the matching craft skills for your prompt and footage.

  • In Mode B (Direct Agent Control): Your agent can search, load, and follow any built-in craft skill directly in its own context window before calling execute_action or execute_batch:

    1. search_skills — search all 100+ craft playbooks by keyword or category (e.g. query: "captions", "color", "podcast", "montage").

    2. load_skill — load the full SKILL.md playbook and its bundled resource list for one or more skill_ids.

    3. read_skill_resource — read specific reference tables or templates (references/..., templates/...) belonging to a skill.

2. 12 Pre-Built Client Skills for Your Agent (skills/*)

This repository includes 12 ready-to-install agent skills under skills/ that teach local agents when and how to invoke Levea:

Skill

Focus

levea-ai-video-editor

Full end-to-end editing (Mode A & Mode B)

viral-clips-generator

Multi-clip viral highlight extraction from long recordings

tiktok-reels-shorts-editor

16:9 → 9:16 active-speaker vertical reframing & hooks

auto-captions-subtitles

280+ word-synced caption templates, translations & dubbing

multicam-podcast-video-editor

Waveform multicam sync & active-speaker switching

silence-removal-audio-cleanup

Word-boundary silence/filler cuts, voiceover & -18 LUFS ducking

ai-b-roll-motion-graphics

Contextual B-roll cutaways, charts, lower thirds & callouts

after-effects-motion-graphics

Shape layers (Trim Paths, Repeaters), Bezier paths & 3D titles

vfx-compositing-keying

Keylight green-screen keying, AI mattes, depth bokeh, LUTs & 328 VFX

motion-tracking-stabilization

2D region tracking, hand palm attachment, 3D camera solve & warp stabilizer

Install all 12 skills in one command:

# Claude Code, Cursor, Codex, OpenCode, Gemini CLI
npx skills add brajendrak00068/agentic-ai-video-production

# OpenClaw / ClawHub
clawhub install levea-ai-video-editor

3. How to Create & Use Your Own Custom Skills (SKILL.md)

You can write your own custom SKILL.md to lock in your channel's house style, brand kit (brandId), preferred caption template (captionTemplatePreset), reference video style (style_reference_url), and exact step-by-step editing recipe.

Where to save your custom skill:

  • Claude Code: .claude/skills/my-show-style/SKILL.md (project) or ~/.claude/skills/my-show-style/SKILL.md (personal)

  • Cursor: .cursor/skills/my-show-style/SKILL.md or .cursor/rules/my-show-style.mdc

  • OpenClaw: ~/.openclaw/skills/my-show-style/SKILL.md (or <workspace>/skills/my-show-style/SKILL.md)

  • Hermes: ~/.hermes/skills/my-show-style/SKILL.md

  • OpenCode: ~/.config/opencode/skills/my-show-style/SKILL.md

Example Custom SKILL.md (Copy & Customize):

---
name: my-show-style
description: "Edit videos in our channel's signature 9:16 house style using Levea MCP."
---

# My Show House-Style Video Edit

When the user asks to edit a clip in our house style:

1. **Load built-in craft guidance (optional):**
   Call `load_skill` with `skill_id: "caption-typography"` to combine Levea's typography rules with our house rules below.

2. **Option A — One-Call Autonomous Edit (`autonomous_edit`):**
   Call `autonomous_edit` with:
   - `brandId`: `"brand_your_kit_id"`
   - `captionTemplatePreset`: `"hormozi"`
   - `style_reference_url`: `"https://your-cdn.com/reference-reel.mp4"`
   - `prompt`: "Cut silences >0.4s and filler words, reframe to 9:16 keeping the active speaker centered, add Hormozi captions in the lower safe zone, add a lower-third title card at 0:02, duck upbeat background music to -18 LUFS under speech, and export 1080p MP4."

3. **Option B — Deterministic Step-by-Step Recipe (`execute_batch` → `render_preview` → `EXPORT_VIDEO`):**
   - Call `execute_batch` on `project_id` with our exact sequence:
     1. `REMOVE_SILENCES` (`min_silence_duration: 0.4`, `padding_ms: 80`)
     2. `CONFIGURE_CANVAS` (`aspect_ratio: "9:16"`)
     3. `VERTICAL_REFRAME` (`mode: "active_speaker"`)
     4. `COLOR_GRADE` (`preset: "cinematic_warm"`, `contrast: 1.08`, `saturation: 1.05`)
     5. `GENERATE_CAPTIONS` (`template: "hormozi"`)
     6. `AUTO_DUCK` (`target_lufs: -18`)
   - Call `render_preview` at `timestamps: [1.5, 5.0, 10.0]` to visually inspect the GPU-rendered JPEG frames and verify captions do not overlap faces.
   - Call `execute_action` with `action: "EXPORT_VIDEO"` to deliver the final MP4.

Once saved, simply tell your agent: "Edit https://.../episode12.mp4 using my-show-style" — your agent reads your custom SKILL.md and drives Levea with your exact rules every time.


🧩 OpenClaw Integration: Plugin vs. Skill

Levea is built for modular agent platforms. When deploying Levea inside platforms like OpenClaw or Hermes, we split execution capabilities from cognitive strategies:

  • The Plugin (openclaw-ai-video-editor): the tools. It registers the edit, direct action, skill discovery, queue, and status tools with their schemas, manages the API key, and streams progress.

  • The Skill (levea-ai-video-editor — or your own custom SKILL.md): the instructions. It tells the agent when to use Levea, which parameters or house-style rules to pass, and how to handle approvals, visual preview checks, long-running edits, and follow-ups.

We recommend installing both to unlock the full power of autonomous editing with a professional finish.


🎬 What It Does: Say It in Plain Language

Say it in plain language; Levea plans, executes, and finishes the complete edit:

You ask

It does

"Turn this into 5 viral clips with captions and vertical reframe"

Identifies narrative peaks, cuts clips, applies bold captions, reframes to 9:16 vertical, and exports.

"Cut a 60-second highlight from this 2-hour podcast"

Discovers strongest continuous story segment, trims dead air, and packages with captions.

"Make this TikTok-ready"

Vertical 9:16 reframe + captions + silence removal + keyword emphasis kit.

"Export for TikTok, Reels, Shorts, YouTube, and Instagram"

One pass, all platform-specific aspect ratios in one package.

"Replace the green screen with a beach, keep the speaker centered"

Chroma key + background composite + face tracking in one call.

"Remove the background — no green screen"

AI background removal via an alpha matte on any footage.

"Swap my background for a city skyline — no green screen"

AI matte isolates subject cleanly, compositing the new background behind.

"Remove all silences and filler words, add background music"

Cleans audio track (cuts um, uh, like), adds ducked music bed under speech.

"Auto-zoom on whoever's talking"

Active-speaker detection + dynamic zoom-follow framing.

"Caption this and highlight every time they say 'launch'"

Auto-captions + keyword emphasis (scaling / glow / pulse).

"Find every clip where Alex appears"

Face identity search across the clips in your project.

"Add narration in a cloned voice over the intro"

Voice cloning + TTS overlay + auto-ducking.

"Caption this Hormozi-style with karaoke word highlighting"

Word-synced karaoke captions — active word fills and underlines in sync with speech.

"Generate B-roll over the product mention"

AI B-roll generation + placement at the exact timestamp.

"Color grade this like a Netflix doc"

Cinematic LUT color grade with contrast and film-look curve.

"Slow-mo the climax, freeze on the reveal"

Speed change (0.5× slow-mo) + freeze-frame hold on key action.

"Reframe to vertical but don't crop the lower-third captions"

Caption-safe 9:16 reframe (detects on-screen text regions and reframes around them).

"Pull the key stats from this and animate them as charts"

Transcript-driven SVG charts (bars, lines, donuts) + animated stat-callout motion graphics.

"Sync these 3 camera angles and cut between them on the active speaker"

Multi-cam audio cross-correlation sync + automatic angle switching.

"Blur the license plates and bleep the swearing"

Privacy redaction (face and moving object blur) + transcript profanity cleanup.

"Turn this YouTube video into a 30-second reel with motion graphics that never cover his face"

Hook-first trim, face-tracked 9:16 reframe, word captions, motion graphics placed clear of every face, ducked music.

"Make a 15-second 3D animation of a little robot racing a deadline"

An original 3D character film with camera moves, lighting, music, and sound design, reviewed by an AI critic before delivery.

"Add upbeat music from the library and a whoosh on every cut"

Licensed music fitted to the video length, sound effects placed on the cuts, voice-aware ducking.

"Speed-ramp into the jump and use J-cuts between speakers"

Speed ramps / time remap and J/L, match, and smash cuts.

"Push the camera in slowly with a little parallax"

Keyframed 3D camera moves with depth-based parallax.

"Match the color of the second camera to the first"

Auto color and shot-to-shot color matching, plus film looks, film burn, and lens flares.

"Dub this into Spanish in my voice and lip-sync it"

Translated dub in a cloned voice, lip-synced to the speaker's mouth. Mouth-to-audio sync is measured and verified, and the dub is checked by listening to it (right language, intelligible). Lines that had to be shortened to fit are reported.

"Put the price tag in her hand and keep it there"

Hand tracking: the overlay follows the palm, can grow and shrink with the hand, and hides while the hand is out of view.

"Mix these four songs into one continuous DJ set"

Beat-matched, harmonically mixed program: each track's tempo and musical key are measured, tracks are time-stretched and key-shifted (Camelot wheel) so they mix.

"Cut a reel from this explainer and keep the slides readable"

Slides, diagrams, and designed graphics are cropped to their content and shown with a headline on a matched background instead of a tiny letterboxed strip.


⚡ Levea vs. Legacy Editors

Capability

Legacy (Premiere, DaVinci, CapCut, Descript)

Levea Agentic Video Editor

Interface

Drag, drop, keyframe by hand on a manual timeline

One natural-language prompt or direct tool call; the agent finishes the edit

Auto-analysis on upload

Manual scene detection + subtitles

Faces, active speakers, shot cuts, and on-screen text regions detected automatically

"Make this viral"

You manually hunt for hooks, crop, splice, and align

Single preset — vertical 9:16 + captions + silences + face tracking

Face search

Filename search

"Find every clip where Alex appears" across the clips in your project

Background replace

Key out green screen or draw rotoscope masks by hand

One call — an AI alpha matte handles any footage without a green screen

Broadcast-grade audio

Manual loudness metering + compression + EQ

Auto LUFS loudness-normalized (EBU R128), true-peak limited, music ducked under speech

Editorial reasoning

You listen and hunt for the climax

Agent surfaces narrative peaks and high-retention moments

Verification & Repair

You eyeball it and manually re-render

Every edit is checked on the rendered frames; failures are repaired automatically and reported with a typed verification report

Multi-platform export

One render per aspect ratio

TikTok + Reels + Shorts + YouTube in one pass

Extensibility

Plugins call external binaries

37 MCP tools unlocking 189+ editing actions, 13 inspection tools, and 100+ craft skills


🎬 Creator & Dev Use Cases

Use case

Typical production path

Faceless channel

Segment the transcript, plan the layout, overlay B-roll, add library or generated music, and render.

Auto-captions

Transcribe, time every word, highlight keywords, and style with a caption template.

Shorts & Reels highlights

Find the hook, trim to the target length, reframe to 9:16 around the speaker, add captions and motion graphics.

Interview polish

Cut long silences, bleep profanity, grade color, and add lower-third speaker graphics.

Green screen & backdrop swap

Key or matte the speaker, layer a new background photo or video, and composite.

Multicam active-speaker cuts

Sync camera angles by audio, identify speakers, and cut to whoever is talking.


⚙️ Verification & Repair

Levea checks its own work before it reports success.

  • Every step is verified when it runs: checks such as "the layer exists", "the timing matches the request", "no graphic covers a face", or "captions stay in sync". A failed check names what was expected and what was found.

  • Automatic repair fixes what failed: it applies targeted fixes and verifies again until the check passes or the request budget runs out, without destroying the user's own layers or breaking earlier steps.

  • A final review looks at the rendered frames of the finished edit and can make further fixes.

  • The agent inspects the result the way an editor would: it watches the rendered video, listens to the rendered audio (is the dub in the right language, intelligible, on-content?), reads color scopes (crushed blacks, clipped whites, flat saturation), previews the frame inside the TikTok / Reels / Shorts interface to check nothing sits under the app's buttons, and measures lip sync on dubbed footage.

  • The result says what happened: verificationReport.status is verified only when that final review approved the edit; unverified means no verdict was reached (the edit is kept, never reported as verified), with every failed check and what repair tried.

  • Corrections are a follow-up prompt with the same project_id. Every revision is saved, so a change can be undone.


📂 Capability Status

Availability of specific tracks varies by deployment, active model tiers, and account quotas.

Supported Production Paths

  • Project and timeline state: Full NLE track and clip operations (insert, overwrite, lift, extract, ripple delete/trim, slip, slide, freeze frame, reverse), multi-track management, nesting containers, and durable linear undo/redo.

  • Captions: automatic captions, word timing, keyword emphasis, 280+ caption templates (Hormozi, Spotlight, Karaoke, Typewriter, phrase lockups, two-line podcast looks, …), animated word entrances and burn-aways, and Latin, Indic, Arabic, Cyrillic, and Greek text.

  • Motion graphics: lower thirds, title cards (59 templates), real 3D extruded bevelled titles, charts, counters, flow diagrams, collage layouts, any-layer behind-the-subject occlusion, native After Effects shape layers (arc-length Trim Paths, Repeaters, shape modifiers — pucker & bloat, zig zag, wiggle paths, round corners, offset paths), spatial Bezier motion paths with auto-orient, graph-editor velocity/influence easing, echo motion trails, and full motion-graphic films (2D motion design and 3D character films with camera, lighting, music, and sound design). Every graphic is placed clear of faces and reviewed by an AI critic before it ships.

  • Editing techniques: speed ramps, time remap, and posterize time, J/L, match, twitch, and smash cuts, keyframed 3D camera moves with depth parallax, non-destructive warp stabilization (smooth camera path + border-hiding auto-scale), AI outpainting to new aspect ratios, eye-contact correction, face retouch, style packages, and 170+ transitions.

  • Layout and perception: multi-cam synchronization and active-speaker cuts, scene and shot cut analysis, face detection and tracking, face identity search across a project's clips, on-screen text-region detection and OCR recognition, safe zones, 2D feature-region tracking (position, rotation, and scale), live null parenting, planar corner-pinning, monocular 3D camera solve, and hand tracking (attach a sticker, label, or prop to a hand's palm).

  • Compositing and color: Keylight-grade screen color key (with despill, clip black/white, softness, shrink/grow), Lab/YUV/RGB color range key, dedicated spill suppression, SVG Bezier masks, feathered/inverted mattes, track mattes, blend modes (all 29 After Effects modes), adjustment layers, ordered multi-effect stacks (up to 4 chained effects per layer), alpha-matte background replacement, on-screen text / logo / watermark removal, auto color and shot matching, monotone cubic curves, CMYK per-range selective color, 5-point levels, LUTs (including your own .cube 1D/3D files), After Effects two-tone threshold glow, depth-map-driven camera lens blur (polygonal iris bokeh), optical lens flares, and 328 procedural VFX presets (film burn, bloom, rain, smoke, fire, glitch, portal, lightning, …).

  • Audio: a reviewed, licensed music and sound-effects library, sound design (effects on cuts and beats, room tone), music fitted to the video length, silence and filler-word cleanup, word-level muting, crossfades, EQ, denoise, EBU R128 loudness normalization, voiceover, voice cloning and voice conversion, speech-aware ducking, beat- and drop-synced edits, measured music structure (sections and drops), musical key detection, DJ mixes (beat-matched, harmonic track-to-track mixing), vocal / instrumental separation, and lip-synced dubbing (translated voice in the speaker's cloned voice, with measured mouth-to-audio sync).

  • Autonomous Directing: automated cold-open hook extraction, hook-first trims to a target length, podcast polish macros, contextual B-roll placement, auto lower thirds, slideshow generation, and reels cut from explainer videos with slides and diagrams cropped to their content.

  • Sources and delivery: public video links (including Google Drive files and folders) checked before planning (Drive files that hit Google's download quota are fetched in the background instead of failing), and MP4 export in every platform aspect ratio.

  • Verification: checks on the rendered frames, requirement tracking, the agent watching and listening to the rendered result (color scopes, platform-UI preview, audio-content and lip-sync checks), brand kits with hard enforcement (off-palette colors fail the check and are repaired), an automatic repair loop, plan approval (requirePlanApproval + planDecision), and a typed verificationReport on every result.

Model- or Deployment-Dependent

  • Generated video, images, B-roll, music, sound effects, voiceover, and voice cloning quality/availability vary by model tier and quota (all are wired as canonical actions in production).

  • Neural alpha matting and background replacement quality.

  • Lip-sync dubbing quality (a lip-sync step passes only on its measured mouth-to-audio sync).

  • CJK caption rendering: right-to-left shaping ships in production; CJK glyph coverage depends on font fallback.


📂 MCP Tool Surface (37 Annotated Tools Unlocking All 189+ Canonical Actions, 13 Read Tools & 100+ Craft Skills)

The MCP server (levea-mcp-server, 37 tools) exposes both high-level goal delegation (autonomous_edit) and direct progressive-discovery & execution (search_tools, get_action_schema, execute_action, execute_batch, render_preview, search_skills, load_skill, read_skill_resource, plus update_layer, delete_layer, trim_layer, apply_transition), alongside typed management and polling tools. The OpenClaw and Hermes plugins expose the same dual-mode editing and discovery surface.

Group

Tools

Description

Mode A: Goal Delegation

autonomous_edit, autonomous_edit_streaming, queue_edit

Send a natural-language brief; Levea's autonomous editing agent inspects the footage, edits, verifies on rendered frames, and exports.

Mode B: Universal Direct Canonical Suite (189+ Actions, 13 Read Tools & 100+ Skills)

search_tools, get_action_schema, execute_action, execute_batch, render_preview, search_skills, load_skill, read_skill_resource

Discover any of the 189+ canonical actions, 13 read tools, and 100+ editing craft skills on demand, execute single actions or atomic batches (with automatic safe-zone checks, timeline reconciliation, and async asset completion), and inspect real GPU-composited JPEG screenshots (render_preview, like ffmpeg frame grabs) without calling autonomous_edit.

Deterministic Layer Shortcuts

update_layer, delete_layer, trim_layer, apply_transition

Fast typed shortcuts for single-layer property updates, deletes, trims, and ~170 named transitions.

Job Polling

check_job_status, check_task_status, get_active_task

Track rendering, generation jobs, and the active task of a project.

Caption Templates

list_caption_templates, apply_caption_template, save_caption_template, save_current_caption_template, delete_caption_template

Manage styling templates (280+ built-in: Hormozi, Spotlight, Karaoke, …); list_caption_templates returns the exact ids.

Brand Kits

list_brand_kits, get_brand_kit, create_brand_kit, update_brand_kit, delete_brand_kit

Manage brand colors, fonts, logos, voice tone, and grading rules.

Projects

list_projects, get_project, create_project, delete_project

Project workspace management.

Assets

asset_upload_url, list_assets, delete_asset, transcribe_asset

Signed upload URLs, asset listing and deletion, and transcription.

Diagnostics

editor_health

Unauthenticated connectivity check.

When to Use Mode A (autonomous_edit) vs. Mode B (execute_action / execute_batch / render_preview)

Scenario

Best Mode

Why

Broad creative brief / full video from prompt

Mode A (autonomous_edit)

Autonomous editing agent + 100+ craft skills handle decomposition, pacing, and verification in 1 call

Exact parameter tweak, custom timestamp math, or local-file-driven script

Mode B (execute_action / execute_batch)

Instant (<50ms), zero backend LLM cost, 100% deterministic control over all 189+ actions

Visual QA loop (like Claude Code ffmpeg frame check)

Mode B (render_preview → execute_action)

Returns real GPU-composited JPEG screenshots (frames[] + MCP image blocks) so your agent can visually verify and nudge layers

Heavy first draft + surgical fine-tuning

Hybrid (Mode A → Mode B)

Fast first draft via autonomous_edit, instant pixel-level polish via execute_action / render_preview

Every edit result carries a verificationReport (verified, rejected, unverified, or not_applicable, plus each requirement that failed its check and what repair tried) and qualityNotes.


🔮 FAQ

How does Levea compare to generic video generators like Sora, Veo, or Runway?

Generic generative video models (Sora, Runway, Veo) output raw, locked pixels. You cannot edit a layer, adjust caption typography, swap background music, or correct a word timing afterward. Levea is a full-featured timeline editor that builds structured project layers. It uses generative models only as optional asset generation steps, keeping your editing pipeline fully editable, inspectable, and deterministic.

Is Levea safe to use for client and enterprise work?

It is designed for it. Every mutation runs through a typed operation engine, and every action the planner or the repair loop chooses is authorized against the request before it runs, so an LLM cannot inject arbitrary mutations. If you set requirePlanApproval: true, the system halts and returns the creative plan for approval; resend with planDecision: "approve" (or an editedPlan) to run it.

What coding and agent environments does Levea support?

Levea integrates natively with Model Context Protocol (MCP) hosts like Claude Desktop, Cursor, Cline, Windsurf, Claude Code, and the Gemini CLI (via the bundled extension). For standalone agent systems, Levea exposes structured packages for OpenClaw and Hermes.

Can I use custom brand fonts, logos, and specific caption templates?

Absolutely. Using our Brand Kits API and tools, you can declare custom typography scales, palette hex codes, logo image references, and voice tone. The planning model reads these rules and automatically enforces them across the timeline during the composition pass.


How long an edit takes: read-only questions answer in seconds, a simple edit with export in a few minutes, and a full edit with motion graphics, music, and export in 10–20 minutes. Clients return status: "running" with the project_id if they stop waiting first; the edit keeps running (see AGENTS.md).

Privacy & telemetry: edits send your prompt, source links, and project ids to the Levea API (privacy policy, terms). The MCP server and OpenClaw plugin also send a tiny anonymous usage ping (event name, client version, whether a key is set; never prompts, media, or keys); turn it off with LEVEA_TELEMETRY=off.

Security: see SECURITY.md. Contributing: see CONTRIBUTING.md.

Support & Contact: brajendra@livecore.ai · GitHub issues


License

MIT

Available Tools

37 tools
apply_caption_templateApply caption templateAInspect

Apply a caption template to a scene synchronously (without going through autonomous_edit).

Inputs: template_id (required), mode, scene, project_id.

apply_transitionApply transitionAInspect

Deterministic edit: apply a named transition between two adjacent clips, committed immediately (the same operation as the editor's transition picker). type is one of ~170 names, e.g. fade, cross_dissolve, dip_to_black, slide_left, push_left, wipe_left, zoom_in, whip_pan, light_leak, glitch, zoom_blur, page_curl, crt_power_off. An unknown name is rejected with the reason. Both layer ids must exist in the project. object_match_cut and parallax_occlusion need face tracking and are refused here — ask autonomous_edit for those.

Inputs: type (required), project_id (required), to_layer_id (required), easing, +3 more.

asset_upload_urlGet asset upload URLAInspect

Get a signed upload URL for a local file (so users do not have to host video / image / audio elsewhere before passing video_url to autonomous_edit). Body: { fileName, fileType?, contentType?, projectId? }. Returns { uploadUrl, fileUrl }; PUT the file bytes to uploadUrl, then pass fileUrl to autonomous_edit as video_url / in assets[].

Inputs: fileName (required), fileType, projectId, contentType.

autonomous_editEdit videoA
Destructive
Inspect

PRIMARY EDIT TOOL. Run a natural-language video edit end-to-end. The backend agent plans, executes, verifies, and exports. Accepts anything from a one-liner ("generate 3 viral clips with captions and export") to a multi-paragraph creative brief. Returns the final mp4 URL synchronously when an export is queued. For long renders you may prefer queue_edit + check_job_status.

Inputs: prompt (required), scene, assets, brandId, +13 more.

autonomous_edit_streamingEdit video (live progress)A
Destructive
Inspect

Same as autonomous_edit but consumes the SSE event stream from the backend. Returns the final terminal result; per-step events (status, thinking, tool_call, tool_result, background_job_completed) are emitted as MCP progress notifications when the client supports them. Use for long-running briefs where users expect live progress.

Inputs: prompt (required), scene, assets, brandId, +13 more.

check_job_statusCheck job statusA
Read-only
Inspect

Poll an export / async job by jobId (numeric). Supports wait:true to block until terminal.

Inputs: job_id (required), wait.

check_task_statusCheck task statusA
Read-only
Inspect

Poll a queued edit task by taskId (returned by queue_edit). Separate from job_id (exports).

Inputs: task_id (required).

create_brand_kitCreate brand kitBInspect

Create a brand profile. Fields: name, palette {primary,secondary,accent,neutral,extras[]}, fonts {primary,secondary}, gradeBias (warm/cool/neutral/vivid/muted), forbiddenColors[], logoAssetUrl, voiceTone, enforcement (soft|hard).

Inputs: name (required), fonts, palette, gradeBias, +4 more.

create_projectCreate projectCInspect

Create a new project. Optional initial brandId.

Inputs: name (required), brandId, description.

delete_assetDelete assetA
Destructive
Inspect

Delete an asset by file name (the path returned by asset_upload_url).

Inputs: fileName (required).

delete_brand_kitDelete brand kitC
Destructive
Inspect

Delete a brand profile.

Inputs: brand_id (required).

delete_caption_templateDelete caption templateB
Destructive
Inspect

Delete a user-saved caption template by id.

Inputs: template_id (required).

delete_layerDelete layerA
Destructive
Inspect

Deterministic edit: permanently delete one or more named layers of a project, committed immediately. close_gap: true ripples the timeline closed and works with a single layer_id only. Selectors such as "all" or "@…" are refused, and so is a delete that would leave the project empty. To hide a layer temporarily use update_layer with {"visible": false} instead.

Inputs: project_id (required), layer_id, close_gap, layer_ids.

delete_projectDelete projectD
Destructive
Inspect

Delete a project.

Inputs: project_id (required).

editor_healthCheck editor healthA
Read-only
Inspect

Connectivity diagnostic against LEVEA_API_URL. Unauthenticated.

Inputs: no named parameters.

execute_actionExecute canonical editor actionA
Destructive
Inspect

Execute any single canonical editor action (all 189+ actions) or read/inspection tool (list_layers, inspect_layer, query_transcript, list_sources, search_shots, shot_timeline, read_source_transcript, measure_audio, measure_picture, measure_color) directly on a project scene without autonomous_edit. Pass video_url or assets on the first call to bootstrap a new project.

Inputs: action (required), scene, assets, video_url, +3 more.

execute_batchExecute canonical action batchA
Destructive
Inspect

Execute an ordered array of canonical actions (and/or read tools) in a single atomic round-trip without autonomous_edit. Automatically runs safe-zone checks, timeline reconciliation, layout de-stacking, async asset completion, and commits the updated scene to project_id.

Inputs: actions (required), scene, assets, video_url, +2 more.

get_action_schemaGet canonical action schemaA
Read-only
Inspect

Fetch the full JSON inputSchema, parameter constraints, and description for any canonical editor action (e.g. COLOR_GRADE, TRIM_LAYER, GENERATE_CAPTIONS, PLAN_MOTION_GRAPHICS, RENDER_PREVIEW, EXPORT_VIDEO) or read tool (e.g. list_layers, query_transcript, inspect_layer).

Inputs: action (required).

get_active_taskGet active taskA
Read-only
Inspect

For a given project, return the currently-running edit task (if any). Useful for reconnecting MCP clients.

Inputs: project_id (required).

get_brand_kitGet brand kitC
Read-only
Inspect

Fetch one brand profile by id.

Inputs: brand_id (required).

get_projectGet projectC
Read-only
Inspect

Fetch one project by id.

Inputs: project_id (required).

list_assetsList assetsB
Read-only
Inspect

List the user's uploaded assets. Optional projectId filter.

Inputs: fileType, projectId.

list_brand_kitsList brand kitsA
Read-only
Inspect

List the user's brand profiles (palette, fonts, logo, voice, gradeBias). Returns ids you pass to autonomous_edit's brandId / projectBrandId.

Inputs: no named parameters.

list_caption_templatesList caption templatesA
Read-only
Inspect

List the user's caption templates (builtin + saved). Returns slugs, display names, and style summaries.

Inputs: no named parameters.

list_projectsList projectsC
Read-only
Inspect

List the user's projects.

Inputs: no named parameters.

load_skillLoad production craft skillA
Read-only
Inspect

Load the full craft playbook (SKILL.md) and bundled resource list for one or more skill IDs returned by search_skills.

Inputs: skill_id, skill_ids.

queue_editQueue video editA
Destructive
Inspect

Fire-and-forget async path. Returns immediately with a taskId. Use when the edit may exceed the MCP request timeout (long viral-clip generation, multi-format export). Poll with check_task_status or get_active_task.

Inputs: prompt (required), scene, assets, platforms, +5 more.

read_skill_resourceRead skill reference resourceA
Read-only
Inspect

Read a bundled reference or template file (e.g. "references/..." or "templates/...") belonging to a production skill.

Inputs: resource (required), skill_id.

render_previewRender GPU preview screenshotsA
Read-only
Inspect

Render real GPU-composited JPEG screenshots of the live project timeline at specified timestamps (and optional normalized 0..1 region crop) — the Levea equivalent of ffmpeg frame extraction, showing all video layers, captions, title cards, color grades, masks, and VFX shaders. Returns native MCP image blocks so you can visually inspect the frames before calling EXPORT_VIDEO.

Inputs: scene, region, project_id, timestamps.

save_caption_templateSave caption templateBInspect

Save a new caption template definition the user can re-apply later.

Inputs: name (required), style (required), tags.

save_current_caption_templateSave current captions as templateBInspect

Snapshot the caption styling currently applied to a project / scene as a reusable template.

Inputs: name (required), scene, project_id.

search_skillsSearch production craft skillsB
Read-only
Inspect

Search Levea production craft skills (SKILL.md playbooks across editing, color grading, captions, audio mixing, motion graphics, VFX, documentary, podcast, and social shorts) by keyword or category.

Inputs: limit, query, category.

search_toolsSearch canonical editor toolsA
Read-only
Inspect

Search all 189+ canonical video editing actions, 13 read/inspection tools, AND canonical preset catalogs (280+ caption templates, 328+ GPU VFX effects, 170+ transitions, 50+ color grade LUTs, 59 title cards, fonts, blend modes) by keyword, category, or catalog filter. Returns matching actions, catalog presets, and the 5-phase NLE editorialPlaybook.

Inputs: limit, query, catalog, category.

transcribe_assetTranscribe assetBInspect

Force transcription of an existing asset. Returns transcript words + timing.

Inputs: fileName (required), language.

trim_layerTrim layerA
Destructive
Inspect

Deterministic edit: shorten a layer, committed immediately. Either a relative trim (edge "start" | "end" + seconds to remove) or an absolute range in TIMELINE seconds (start_time + end_time: the part of the layer's current window to keep). On a single-source cut timeline the trim ripples later segments closed. A trim that removes nothing is an error (NO_CHANGE).

Inputs: layer_id (required), project_id (required), edge, seconds, +2 more.

update_brand_kitUpdate brand kitC
Destructive
Inspect

Update an existing brand profile by id. Body has the same shape as create_brand_kit.

Inputs: brand_id (required), name, fonts, palette, +5 more.

update_layerUpdate layerAInspect

Deterministic edit: set registry properties on one existing layer of a project, committed immediately (no planner, no export). E.g. {"x": 540, "y": 960}, {"scale": 1.2}, {"opacity": 0.5}, {"volume": 0.3}, {"visible": false}, {"z_index": 4}, or its timeline window {"start_time": 2, "end_time": 8}. Unknown keys are ignored, and an update that changes nothing is an error (NO_CHANGE). Not for keyframed animation (use autonomous_edit), and not "text" on a caption group (refused: it would overwrite every caption). Get layer ids from get_project (project.scene.layers[].id).

Inputs: layer_id (required), project_id (required), properties (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 37 tools

    Disambiguation3/5

    Descriptions do a lot of work to separate overlapping paths (autonomous_edit vs autonomous_edit_streaming vs queue_edit, execute_action vs execute_batch vs the deterministic update_layer/trim_layer/apply_transition tools), but there are still several routes to the same outcome, so an agent must reason carefully to pick one. get_action_schema, search_tools, and execute_action also partially overlap in discovery/schema-fetching roles, and apply_caption_template vs save_current_caption_template vs apply_caption_template can be confused at a glance.

    Naming Consistency4/5

    Nearly all names follow a predictable snake_case verb_noun pattern (list_projects, create_brand_kit, delete_layer, check_job_status). A few outliers break the verb-first convention (editor_health, asset_upload_url, autonomous_edit_streaming), but they remain readable and unambiguous.

    Tool Count2/5

    At 37 tools the surface is heavy for a single server, and several earn only marginal place (autonomous_edit_streaming largely duplicates autonomous_edit, get_action_schema overlaps search_tools, and caption-template save/snapshot are split into two tools). The broad domain (editing, brand kits, assets, skills, jobs) explains some breadth but does not justify the full count.

    Completeness4/5

    Coverage is strong: full CRUD for projects and brand kits, complete caption-template lifecycle, asset upload/list/delete/transcribe, job and task polling, and both high-level agentic and deterministic edit paths plus skills discovery. Minor gaps exist — no project update/settings operation and no get_caption_template detail fetch — but these are workaroundable.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers