# WeftCut

> Free, open-source AI video editor for macOS, Windows and Linux — drive the whole timeline from Claude, Cursor, or any MCP client.

- **Type:** MCP server
- **Install:** `agentstack add mcp-weftcut-weftcut`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [WeftCut](https://agentstack.voostack.com/s/weftcut)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [WeftCut](https://github.com/WeftCut)
- **Source:** https://github.com/WeftCut/WeftCut
- **Website:** https://weftcut.com

## Install

```sh
agentstack add mcp-weftcut-weftcut
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

WeftCut

  The video editor your AI agent can actually drive.
  Point Claude, Cursor, or any MCP client at a real desktop NLE — and watch
  every edit land on your timeline while it plays.

  
  
  
  weftcut.com

An agent at work over MCP while playback runs: restyling the
lower third, trimming the B-roll, then undoing both — every edit lands in the UI
in real time, and the Agent panel records what it did.

Most editors bolt AI on as a feature: a button that generates something, a
sidebar that suggests a cut. WeftCut exposes the editor *itself* as a tool
surface. A localhost MCP server publishes **88 editing tools** — place, trim,
split, restyle, keyframe, group, caption, mix, checkpoint — and whatever agent
you already have open drives them. The intelligence lives outside the app: the
installer bundles no model weights, and the local engines for speech and vision
are an opt-in download when you want them.

None of that rides on a stripped-down editor. Everything an agent can reach, you
can do by hand, in a full NLE: A/B-roll timeline, keyframes with a curve editor,
effects, captions, a role-based audio mixer, and hardware-accelerated export.

## Install

| Platform | Download |
|---|---|
| **Windows** | [WeftCut-win-x64.exe](https://github.com/WeftCut/WeftCut/releases/latest/download/WeftCut-win-x64.exe) |
| **macOS** (Apple Silicon) | [WeftCut-mac-arm64.dmg](https://github.com/WeftCut/WeftCut/releases/latest/download/WeftCut-mac-arm64.dmg) |
| **Linux** | [AppImage](https://github.com/WeftCut/WeftCut/releases/latest/download/WeftCut-linux-x86_64.AppImage) · [.deb](https://github.com/WeftCut/WeftCut/releases/latest/download/WeftCut-linux-amd64.deb) |

Windows updates itself in the background. The macOS build is ad-hoc signed and
not notarized, so it neither self-updates nor opens on the first try — allow it
under **System Settings → Privacy & Security → Open Anyway**. All releases:
[github.com/WeftCut/WeftCut/releases](https://github.com/WeftCut/WeftCut/releases).

## Hand your timeline to an agent

Copy the MCP URL and token the app prints on startup (also available in-app)
into your client's config, and your agent is holding the editor.

- **It edits the project you are watching.** No import/export round trip, no
  separate headless copy. The agent calls `trim_layer`, the block shortens
  under the playhead while audio keeps playing, and your next click continues
  from there.
- **You can always see what it did.** Every tool call becomes a row in the
  Agent panel — *Trimmed clip · Ember.mp4*, *Added marker · Needs a look* — and
  the status bar echoes it. Nothing happens off the record.
- **Every batch is reversible.** Agents checkpoint at logical boundaries
  (`checkpoint`), and each checkpoint is one click from being restored. The
  agent can also rehearse a whole multi-step edit against a throwaway clone
  first (`dry_run`) and find the collision before it touches your project.
- **Multi-agent, with rules.** Sessions are per-connection. An agent that is
  mid-batch can `lock_history` so a stray Ctrl-Z doesn't land in the middle of
  its work — and the lock, plus the reason it gave, is shown to you.

For a longer run, an agent can call `begin_agent_session` and fold the UI down
to preview, scrub, and a record of what it is doing:

## Code as video: Motifs

A **Motif** is an on-screen element written as code — a real web page (HTML,
CSS, SVG, canvas, WebGL, whatever you reach for) dropped on the timeline as a
layer. It isn't a fixed preset: the author declares the knobs, and the inspector
builds the form from that declaration, so `seconds`, `label` and `accent` below
are editable in the app because the Countdown's manifest says they are.

The one rule that makes it an editor feature instead of a screen recording:
**a Motif renders as a pure function of time.** It never advances itself. The
harness owns the clock and drives the page to each composition frame, so the
same `t` always yields the same pixels — when you scrub, when you re-export,
and in preview and export alike.

```js
// The built-in Countdown's whole script, near enough verbatim — the rest of the
// file is the SVG ring it animates. `props` is whatever the manifest declares;
// `frame` runs once per composition frame and keeps no state of its own.
motif.define({
  setup: async function (props, ctx) {
    _label = props.label != null ? String(props.label) : "GO";
    num.style.color = props.accent;
    ring.style.stroke = props.accent;
    ring.setAttribute("stroke-dasharray", C);
    ring.animate([{ strokeDashoffset: 0 }, { strokeDashoffset: C }],
      { duration: ctx.duration * 1000, easing: "linear", fill: "both" });
  },
  frame: function (t, ctx) {
    var n = Math.max(0, Math.ceil(ctx.duration - t));
    num.textContent = n > 0 ? String(n) : _label;
  },
});
```

Which is where agents and video stop being two separate ideas. Writing a web
page is the thing coding agents are already best at — so an agent can author a
brand-new overlay for your edit instead of picking one from a catalog:

`write_motif_draft` writes it · `preview_motif_draft` **renders a frame back as
a PNG so the agent can look at its own output and fix it** · `add_motif` puts
the draft on the timeline · `install_motif` publishes it to your catalog for
good. The authoring spec ships inside the app as an agent skill, so the model
gets the contract without you pasting documentation.

Lower thirds, countdowns, karaoke text and animated title cards are the obvious
uses. Anything you can build on a page is the actual limit.

## A complete editor underneath

**Timeline** — A/B-roll rows with filmstrips and waveforms, frame-accurate
SMPTE editing, ripple delete that closes the gap behind it, linked A/V that
trims as one clip, cross-track groups, and nested compositions.
Agent: `move_layer` · `trim_layer` · `split_layer` · `ripple_delete_gap` · `links_create` · `groups_create` · `move_layers_to_composition`

**Keyframes** — animate any parameter, with bézier easing, a curve editor,
tangent control, motion paths and extrapolation.
Agent: `set_keyframe` · `set_keyframe_easing` · `set_keyframe_tangents` · `smooth_keyframes` · `set_extrapolation`

**Speech and captions** — transcribe a clip and get editable caption layers
packed onto your caption tracks; import SRT/VTT/ASS the same way. Transcription
runs against a cloud provider, or entirely on your machine once you let the app
fetch a local engine (whisper.cpp, FunASR). Text-to-speech for scratch voiceover.
Agent: `transcribe_clip` · `apply_subtitles` · `synthesize_speech`

**Audio** — role-based mixing (dialogue / music / SFX / voiceover) with live
per-role metering, gain, pan, fades and denoise. **Pauses** finds the dead air
in a take and cuts it as one undoable edit, keeping a pad so speech still
breathes.
Agent: `detect_pauses` · `remove_pauses` · `set_role_gain` · `set_role_flags`

**Understanding the footage** — shot-boundary detection with per-shot
brightness, motion and sharpness, frame comparison, and vision-model
descriptions of what a clip actually contains. An agent can cut on content, not
just on timecode.
Agent: `analyze_clip` · `auto_split_by_shot` · `describe_clip` · `compare_frames`

**Titles, effects and transitions** — styled text layers with outlines, per-layer
effect chains including chroma key with an eyedropper that picks from the live
frame, and transitions between clips.
Agent: `add_effect` · `update_effect` · `add_transition` · `update_transition`

**Export** — H.264 / HEVC / AV1 up to 10-bit, hardware or software encoders,
resolution / fps / quality controls, and streamed muxing that never buffers the
whole render in memory.

**Find anything** — one `Ctrl+K` palette over commands, media, clips, captions
and markers, with pinyin support.

## Under the hood

Electron shell with a React 19 UI; the preview composites through **PixiJS v8 +
WebCodecs** on a ``, and export runs the same compositor in a Worker on
an `OffscreenCanvas`. A **Rust** core (napi-rs) does decoding, audio mixing,
media analysis and background jobs; **ffmpeg** handles the codecs it doesn't;
`mediabunny` demuxes and muxes. The agent surface is MCP over streamable HTTP.

The design choices behind that, and why several of them were reversed, are
written down as [ADRs](docs/adr/).

## Build from source

Prerequisites: **Node 24+**, **Rust** (stable via `rustup`), and your platform's
C++ build tools — per-OS commands in [docs/setup.md](docs/setup.md).

```sh
npm install       # JS dependencies
npm run bootstrap # one-time: fetch ffmpeg + build the Rust addons
npm run dev       # start the editor
```

Also useful: `npm run typecheck`, `npm test`, `npm run e2e`, `npm run build`,
`npm run package` (installers).

## Documentation

Start with **[architecture](docs/architecture.md)** for the system map, or
**[MCP server & agent UX](docs/mcp.md)** for the tool surface, resources and
multi-agent behavior. **[Motifs](docs/motifs.md)** and
**[motif authoring](docs/motif-authoring.md)** cover the overlay engine and its
contract.

Everything else

- **[Data model](docs/data-model.md)** — project state schema, history, persistence, validation.
- **[Render](docs/render.md)** — PixiJS + WebCodecs renderer architecture.
- **[Preview](docs/preview.md)** — interactive preview surface and transport.
- **[Export](docs/export.md)** — export settings and range, audio export, final mux, proxies, background jobs.
- **[Captions](docs/captions.md)** · **[Audio](docs/audio.md)** — caption ingestion and the audio engine.
- **[Conformance](docs/conformance.md)** — media fixtures and E2E gates for frame alignment, audio sync, colour.
- **[Features](docs/features.md)** — small-feature contracts: undo-stack scope, groups, search palette, colour picker.
- **[Status / log system](docs/status-log.md)** — the bottom-of-editor log bus.
- **[Setup](docs/setup.md)** — per-OS toolchain prerequisites and first-run flow.
- **[Licensing](docs/licensing.md)** — MIT app plus the two FFmpeg lanes and their build-time compliance gates.
- **[v1 target](https://github.com/WeftCut/WeftCut/issues/11)** — release scope and open work, tracked as an issue: `docs/` describes what exists today.

## Maintainer

WeftCut is built and maintained by [UncleChair](https://github.com/UncleChair).

It exists to speed up my own video work. I wanted an editor an agent could
actually drive, and a timeline I could keep watching while it did — so the MCP
surface is the part I use daily, not a demo bolted onto the side. Motifs came
from the other half of that: the overlays I wanted were easier to *write* than
to find, and an agent that can write a web page can write one for the shot in
front of it.

The project sits under the [WeftCut](https://github.com/WeftCut) organization so
the name, domain and releases have a stable home, but it is a one-person
project — issues and pull requests all reach me.

## License

WeftCut is licensed under the [MIT License](LICENSE). Packaged installers
bundle FFmpeg binaries under their own licenses (LGPL shared libraries for
in-process decode, GPL command-line tools run as a separate process) — see
[THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md) and
[docs/licensing.md](docs/licensing.md) for the full model.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [WeftCut](https://github.com/WeftCut)
- **Source:** [WeftCut/WeftCut](https://github.com/WeftCut/WeftCut)
- **License:** MIT
- **Homepage:** https://weftcut.com

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-weftcut-weftcut
- Seller: https://agentstack.voostack.com/s/weftcut
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.