We’ve already unpacked the generation side of AI short dramas in the previous two posts (LibTV Production Pipeline, Open-Source Alternatives), but there’s one more hurdle after the clips are produced: editing. Storyboard assets, voiceover, subtitles, BGM, and transitions — the traditional approach means dragging things around in CapCut/JianYing for hours manually.

In 2026, this pipeline can be handed off to agents too. This post covers five MCP routes that are already working end-to-end, with full configuration code — both Hermes and Claude Code are compatible.

First, the Panorama: How to Choose Among Five Routes

The shared principle boils down to one sentence: none of these tools render video — they generate project files that JianYing/PR can open, or directly manipulate an already-open project. Rendering and final export are still handled by the host software; the AI is responsible for “assembling the blocks.”

Route 1: cutcli — Script-Generated JianYing Drafts, Cleanest Approach

cutcli (cookbook at xuliang2024/cutcli-cookbook) is a CapCut/JianYing draft CLI: a single command creates a draft, adds assets, and applies subtitles — the generated draft appears directly in JianYing Desktop’s draft list, fully WYSIWYG and ready for manual tweaking.

1
2
3
4
5
6
7
8

# Install
curl -s https://cutcli.com/cli | bash

# Run the first example
git clone https://github.com/xuliang2024/cutcli-cookbook.git
cd cutcli-cookbook/examples/01-hello-caption
bash run.sh
# Open JianYing — the new draft is already in the list

Its agent-friendliness is the highest of the five. The cookbook’s prompts/claude/ directory provides Claude Code system prompts out of the box. The core idea is to have the model play two roles:

1. Storyboard artist first: output a markdown table with shot number, timecode, visuals, subtitles, music, and transitions
2. cutcli engineer next: translate that table into run.sh — times in integer microseconds, complex JSON split into data/*.json, comments before every add command, and chain the flow with DRAFT_ID=$(cutcli draft create ... | jq -r '.draftId')

No need to guess asset names — query commands are there to fall back on:

1
2
3

cutcli query text-animations --type in      # subtitle animation names
cutcli query transitions --action search --keyword 推近
cutcli query filters --action search --keyword 暖色

The cookbook also includes 30+ JSON templates (vlog, product promo, subtitle cards) and v1.3.9 cloud rendering capability, under the MIT license.

Route 2: jianying-mcp — Use It When You Need Keyframe and Effect Granularity

hey-jian-wei/jianying-mcp (Apache-2.0, Python 3.13+) wraps pyJianYingDraft as a standard MCP server with extremely fine-grained tools: add_video_keyframe (keyframe animation), add_video_mask (masks), add_text_bubble (subtitle bubbles), find_effects_by_type (enumerate available effects) …

Installation and Claude integration (uv method, verbatim from the official README):

1
2
3
4
5
6

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone and install dependencies
git clone https://github.com/hey-jian-wei/jianying-mcp.git
cd jianying-mcp && uv sync

MCP client configuration (Claude Code’s ~/.claude.json or Hermes config, see below):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

{
  "mcpServers": {
    "jianying-mcp": {
      "command": "uv",
      "args": ["--directory", "/your-path/jianying-mcp/jianyingdraft", "run", "server.py"],
      "env": {
        "SAVE_PATH": "/your-path/draft",
        "OUTPUT_PATH": "/your-path/output"
      }
    }
  }
}

It even ships a built-in rules tool — “video production guidelines” — that makes the agent read the spec before touching anything. That’s a smart way to bake editing expertise directly into the MCP layer.

Route 3: capcut-mcp — HTTP Interface, Works with Both Chinese JianYing and International CapCut

fancyboi999/capcut-mcp takes the HTTP route: a local service (default port 9000) exposing /create_draft, /add_video, /add_subtitle, /add_effect, /save_draft and similar endpoints, while also mounting an MCP endpoint. It supports draft formats for both the Chinese JianYing and the international CapCut.

Claude-side configuration is minimal:

1
2
3
4
5
6
7
8

{
  "mcpServers": {
    "capcut-mcp": {
      "type": "http",
      "url": "http://localhost:9000/mcp"
    }
  }
}

The HTTP protocol means it’s not limited to MCP clients — curl scripts, n8n workflows, and your own Python pipelines can call it directly. Great for embedding it as a “editing backend” inside an automation system.

Route 4: OpenChatCut — If You Want an “AI Version of JianYing” Itself

0xsline/OpenChatCut (★1949, actively developed) is a different species entirely: a full open-source video editor (React 19 + Remotion 4 + Electron 43, multi-track timeline), and at the same time agent-native — Codex, Claude Code, and its built-in agent can all read, edit, and export projects, with full editability preserved.

Connecting to Claude Code takes just one command to install the skill:

1

npx skills add 0xsline/OpenChatCut

Then tell the agent Set up OpenChatCut. It exposes a Streamable HTTP MCP endpoint (http://localhost:5199/api/external-mcp/mcp), and the root .mcp.json already contains the local connection config.

The design aspect most worth learning is the edit session mechanism:

1. begin_edit_session returns an editSessionId
2. All subsequent reads and writes carry this id; changes land only on an isolated draft
3. review_edit_session submits for review
4. In manual mode, a human previews, approves, or rejects in the editor; in auto mode, changes take effect immediately

AI mistakes never contaminate the original project — rollback granularity is “one proposal.” That’s a critical guardrail for production environments. Custom skills go in ~/.openchatcut/skills/<slug>/SKILL.md, structured identically to the Claude/Codex skill directories.

Route 5: Premiere Pro MCP — Pro Post-Production for PR Users

hetpatel-11/Adobe_Premiere_Pro_MCP (MIT, npm package) bridges local Premiere through a CEP panel, exposing 283 tools (behind search_tools and invoke_tool entry points) plus 13 resources and 10 guided prompts. Timeline editing, color grading, and audio are all covered.

1
2
3
4

npm install -g adobe-premiere-pro-mcp
premiere-pro-mcp --install-cep    # Install CEP bridge + configure MCP client
premiere-pro-mcp --doctor         # Self-check
# Restart PR → Window > Extensions > MCP Bridge (CEP) → launch the bridge

Claude Code has an official plugin path:

1
2

/plugin marketplace add .
/plugin install premiere-pro-mcp@adobe-premiere-pro-mcp

Same story for Codex (codex plugin marketplace add .). Verify the connection with one command: ask Claude to run verify_premiere_connection. Note that all three (PR, MCP client, and this package) must run on the same machine — the UXP bridge is still experimental; use CEP for production.

How to Wire This Up in Hermes

Hermes Agent has native MCP server support. Configuration goes under the mcp_servers key in ~/.hermes/config.yaml, supporting both transport types. Using jianying-mcp (stdio) and capcut-mcp (HTTP) as examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

mcp_servers:
  jianying:
    command: "uv"
    args: ["--directory", "/home/you/jianying-mcp/jianyingdraft", "run", "server.py"]
    env:
      SAVE_PATH: "/home/you/draft"
      OUTPUT_PATH: "/home/you/output"
    timeout: 180
  capcut:
    url: "http://localhost:9000/mcp"
    timeout: 180

After editing, restart Hermes. Tools register into every platform toolset under the mcp_jianying_* and mcp_capcut_* prefixes. Then you can say something like “edit the storyboards under /videos into a 60-second vertical cut per the shot list, with white-background black-text subtitle bubbles” and it becomes an executable instruction.

On the Claude Code side, write the equivalent into .mcp.json (JSON format identical to the examples above). Project-level config goes in the repo root; global config goes in ~/.claude.json.

My Recommended Combo

Building on last time’s drama production line, the minimum-hand-work division of labor is:

1. Asset layer: Toonflow / LocalMiniDrama generates characters, scenes, and storyboard clips (previous post)
2. Structure layer: Claude Code + cutcli — auto-generates storyboard tables from scripts, translates them into run.sh, and batch-drops drafts
3. Refinement layer: Open the draft in JianYing; the human does only three things: picks the best takes, checks voiceover timing, and fine-tunes transition feel
4. Export layer: cutcli v1.3.9 cloud rendering or JianYing export

Offload all the mechanical “dragging tracks” labor to agents; human time goes toward aesthetic decisions. Based on the row-and-column count of a storyboard table, a 20-shot vertical short that would take roughly 2 hours of manual editing gets compressed to 10 minutes of review plus a bit of hand-tweaking.

Two practical reminders: use absolute paths for drafts — JianYing’s resolution of relative paths often disagrees with the agent’s working directory — and add_video_segment’s duration unit is microseconds. Claude occasionally writes milliseconds instead. After the first successful run, have it self-check the unit conversion.

Sources & Verification

Installation commands, configuration snippets, and session-mechanism descriptions for all five routes are sourced from each project’s official README and docs (pulled via the GitHub API, verified 2026-09-21). Star counts: cutcli-cookbook ★195, jianying-mcp ★293, capcut-mcp ★96, OpenChatCut ★1949, Premiere Pro MCP ★593. The Hermes mcp_servers config format comes from the Hermes Agent official documentation.