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

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 production harness: frame-accurate cuts, 60+ 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.

🧭 How Levea Routes Your Request

Every request is first classified into one production type, from your prompt and your footage (is there speech? faces? one long recording or many short clips?). Each production type maps to exactly one production pipeline, and the pipeline decides which editing craft (director skills) the planner works with. The planner can still load extra skills while it reviews your footage.

Good to know

• Your footage counts, not just your words. "Launch reel for our new podcast studio" over silent clips of an empty set is a showcase, not podcast clipping, because a podcast pipeline needs speech.

• Links in your prompt get a role. A URL is classified as footage to import, a style reference, your brand's site (used for palette and tone, not shown on screen unless you ask) or a website to show.

• Want a specific pipeline? Say so in plain words ("treat this as a documentary montage"); the classifier reads it.

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 project and timeline (Scene IR) containing assets, text, masks, audio, and brand kits.

• Frontier LLMs for Planning: We use probabilistic Frontier LLMs solely for planning, semantic analysis, and parameter parsing.

• Cloud-Accelerated Production Harness: Heavy computation (Vulkan rendering, GPU transcription, active-speaker face tracking, and HyperFrames motion graphics) executes 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 sign-in or an API key. Create a free account and API key at livecore.ai.

🏗️ Platform Architecture

Levea separates probabilistic creative reasoning from deterministic project execution: a language model decides what to do, as a typed plan; deterministic code decides how, changes the project, and checks the result.

        Creative Intent + Source Media (video links, transcript, references)
                                  │
                                  ▼
          Production Pipeline + Director Skills
          (reel, podcast, documentary, motion graphics, …)
                                  │
                                  ▼
        Multimodal Planner (frontier LLM: prompt, transcript, frames, scene)
                                  │
                                  ▼
                Typed Action Plan (186 canonical actions)
                                  │
                                  ▼
     Plan Compiler (schema validation, parameter binding, dependency order)
                                  │
                                  ▼
          Workflow DAG (tasks, dependencies, gates, verifiers)
                                  │
                                  ▼
      Execution Harness ── typed, audited operations ──▶ Scene IR
      │                                                (timeline, tracks, layers;
      │                                                 every revision saved)
      ├── Perception: transcript, faces, active speaker, shot cuts, on-screen text
      ├── Editing: cuts, ripple, slip/slide, reframe, multicam, speed ramps
      ├── Captions: 60+ templates, word-level sync, Latin/Indic/Arabic/Cyrillic/Greek
      ├── Audio: licensed music + SFX library, sound design, EBU R128, ducking, voiceover
      ├── Motion graphics (HyperFrames): 2D motion design, 3D character films, charts
      ├── Generation jobs: images, B-roll video, music, voice (async artifacts)
      └── Rendering (Vulkan / WebGPU): 160+ transitions, ~100 GPU effect presets
                                  │
                                  ▼
      Verification: each task's checks, then a final review of the rendered frames
              │  fails                                  ▲
              └──▶ Repair loop: typed fixes, re-verified ┘
                                  │ passes (or budget spent: reported, never hidden)
                                  ▼
      Editable Scene + verification report ──▶ MP4 / multi-platform export

How the clients connect

Every Levea client reaches the same editor on the Levea backend. The agent clients are thin wrappers over one HTTP API, with the same edit fields (one shared edit contract); the web studio and the Telegram bot have their own routes into the same editor. Pick whichever fits your tools:

               Levea editor (one edit pipeline, same result everywhere)
                                           ▲
               ┌───────────────────────────┼─────────────────────────┐
               │                           │                         │
           Levea API               Web studio route           Telegram route
  /api/v1/misc/openclaw/v1/*    /api/v1/misc/editor/*    /api/v1/misc/telegram/*
  (execute, queue-edit, jobs,              ▲                         ▲
   task-status, projects, assets, …)       │                         │
               ▲                   Levea web studio            Telegram bot
               │                    (livecore.ai)          (@Levea_editing_bot)
          ┌────┴───────────┬────────────────┬────────────────┐
          │                │                │                │
  levea-mcp-server  OpenClaw plugin   Hermes plugin   ChatGPT action
  (npm, stdio MCP)     (ClawHub)        (Python)         (OpenAPI)
          ▲
  Hosted MCP: /api/v1/misc/mcp
  (the same server, run by Levea; OAuth sign-in or API key)
          ▲
  Claude Code plugin · Claude connector · ChatGPT app · Cursor plugin ·
  Gemini CLI extension · Grok Bot · Mistral · any remote-MCP client

All paths start with https://api.livecore.ai.

• MCP clients (Claude Desktop, Cursor, Cline, Windsurf) run levea-mcp-server locally with an API key, or connect to the hosted MCP URL with no install.

• Cursor plugin (.cursor-plugin marketplace) and Gemini CLI extension (gemini-extension.json) install from this repo and ride the hosted MCP server — nothing to run locally. Grok Bot (add the hosted MCP by URL: https://api.livecore.ai/api/v1/misc/mcp) and Mistral (Le Chat connectors) reach it the same way.

• OpenClaw, Hermes, and the ChatGPT action call the API directly.

• Telegram: message @Levea_editing_bot to edit from your phone. Link it to your Levea account from the sign-in page ("Try on Telegram").

• Skills (ClawHub, the Claude Code plugin) are instructions for the agent; they do not run code.

Directory — every box in the map above, linked:

1. Pipelines and planning

Each request is matched to a production pipeline (a short-form reel, a podcast cut, a documentary montage, a motion-graphic film, …) whose director skills give the planner its craft rules. The planner reads the prompt, the transcript, sampled frames, and the current scene, and emits a typed action plan: canonical actions with typed parameters, never free-form scene edits.

2. Compilation, Workflow DAG and Scene IR

The plan compiler validates every action against its schema, binds parameters, and orders the work into a Workflow DAG of tasks, dependencies, gates, and verifiers. Tasks change the Scene IR (the serializable project: canvas, tracks, layers, transitions, effects, assets) only through typed, audited operations, so every edit is inspectable and repeatable, and the project never belongs to the language model.

3. Execution Harness

Typed operators run on the cloud GPU cluster: perception, editing, captions, audio, and rendering through native Vulkan (export) and browser WebGPU (preview) from one shared scene-preparation path. Motion graphics come from HyperFrames: editorial layouts, data charts, stat cards, diagrams, and short 3D character films with their own camera, lighting, music, and sound design. Every motion graphic is reviewed by an AI critic against a craft checklist and revised before it reaches the timeline.

4. Versioning and Export

All revisions are saved in a durable, linear undo/redo history backed by immutable scene payloads, preventing state corruption during multi-step iterations. Export is optional—Levea can return the updated editable scene, queue asset rendering, deliver an MP4, or bundle assets for multi-platform delivery.

🛠️ 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, 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.

🎨 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, 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."

🧩 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, queue, and status tools with their schemas, manages the API key, and streams progress.

• The Skill (levea-ai-video-editor): the instructions. It tells the agent when to use Levea, which parameters to pass, and how to handle approvals, long-running edits, and follow-ups. The editorial craft itself (pipelines, director skills, verification) runs on the Levea backend.

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:

⚡ Levea vs. Legacy Editors

🎬 Creator & Dev Use Cases

⚙️ Verification & Repair

Levea checks its own work before it reports success.

• Every task is verified when it runs: typed 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 the invariant, what was expected, and what was found.

• A repair loop fixes what failed: it proposes typed fixes (any canonical action), applies them, and verifies again, until the check passes or the request's time and model-call budget runs out. A fix is refused if the request prohibits it, if it would destroy the user's own layers, or if it would break a task that already passed.

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

• 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, 60+ 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, charts, counters, flow diagrams, collage layouts, text behind the subject, 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 and time remap, J/L, match, and smash cuts, keyframed 3D camera moves with depth parallax, AI outpainting to new aspect ratios, eye-contact correction, face retouch, style packages, and 160+ 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, and explicit-region tracking or masking.

• Compositing and color: chroma key, masks, blend modes (29 modes), adjustment layers, alpha-matte background replacement, on-screen text / logo / watermark removal, auto color and shot matching, LUTs (including your own .cube files), and ~100 GPU effect presets (lens flares, 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, and vocal / instrumental separation.

• Autonomous Directing: automated cold-open hook extraction, hook-first trims to a target length, podcast polish macros, contextual B-roll placement, auto lower thirds, and slideshow generation.

• Sources and delivery: public video links (including Google Drive files and folders) checked before planning, and MP4 export in every platform aspect ratio.

• Verification: typed task contracts, checks on the rendered frames, requirement tracking, 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.

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

📂 MCP Tool Surface

The MCP server (levea-mcp-server, 25 tools) exposes one high-level editing entry point plus typed management and polling tools. The OpenClaw and Hermes plugins expose the five edit and polling tools.

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.

🔗 Links & Resources

• Levea Studio and API Keys: livecore.ai

• npm MCP Server Wrapper: levea-mcp-server

• MCP Registry: io.github.brajendrak00068/levea-mcp-server

• OpenClaw Plugin Page: openclaw-ai-video-editor

• OpenClaw Skill Page: levea-ai-video-editor

• Detailed Agent Integration Guide: AGENTS.md

• MCP Folder Documentation: mcp-server/README.md

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