# FableCut (npm · fablecut)

Zero-dependency browser video editor AI agents drive via a JSON timeline over MCP; ffmpeg export.

- Trust score: 79/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-17

## Components

- mcpb · `fablecut.mcpb`: 14/100, [markdown](https://verifymcp.io/servers/ronak-create-fablecut/https-github-com-ronak-create-fablecut-releases-download-v1-6-0-fablecut-mcpb.md), [page](https://verifymcp.io/servers/ronak-create-fablecut/https-github-com-ronak-create-fablecut-releases-download-v1-6-0-fablecut-mcpb)
- npm · `fablecut`: 79/100 (this document), [markdown](https://verifymcp.io/servers/ronak-create-fablecut/fablecut.md), [page](https://verifymcp.io/servers/ronak-create-fablecut/fablecut)

## Channel facts

- Registry: `npm`
- Package: `fablecut`
- Version: `1.14.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-17.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to ronak-create/FableCut).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6201 tokens (~442/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 14 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the FableCut MCP server?

FableCut runs locally as an npm package, launched with npx -y fablecut. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ronak-create-fablecut -- npx -y fablecut
```

### Cursor

```json
{
  "mcpServers": {
    "ronak-create-fablecut": {
      "command": "npx",
      "args": [
        "-y",
        "fablecut"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ronak-create-fablecut": {
      "command": "npx",
      "args": [
        "-y",
        "fablecut"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ronak-create-fablecut -- npx -y fablecut
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ronak-create-fablecut": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "fablecut"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ronak-create-fablecut --command npx --arg -y --arg fablecut
```

### Hermes

```yaml
mcp_servers:
  ronak-create-fablecut:
    command: "npx"
    args: ["-y", "fablecut"]
```

### Netclaw

```json
{
  "McpServers": {
    "ronak-create-fablecut": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "fablecut"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ronak-create-fablecut -t stdio -c npx -a -y fablecut
```

### Other

```json
{
  "mcpServers": {
    "ronak-create-fablecut": {
      "command": "npx",
      "args": [
        "-y",
        "fablecut"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-14 (score 79, +29)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100

### 2026-10-12 (score 50)

First indexed and scored.

## MCP tools (14)

### `fablecut_status` (~48 tokens)

FableCut video editor: ensure the editor web server is running (auto-starts it), and get the editor URL, project summary and media library. Call this first in a session.

### `fablecut_docs` (~112 tokens)

Return the FableCut project schema documentation: clips, tracks, props, keyframe animation, transitions, and editing recipes. Read this before editing. TOKEN TIP: pass `section` to fetch only the '## …' section(s) you need (substring match, e.g. "props", "Recipes", "Remake") instead of the whole manual.

Input parameters:

- `section` (string): Return only '## ' sections whose heading contains this text (case-insensitive). Omit for the full document.

### `fablecut_get_project` (~88 tokens)

Get the FableCut project (the timeline document). TOKEN TIP: pass compact:true for a one-line-per-clip summary (ids, tracks, timings, non-default props) — usually all you need to plan an edit; fetch the full JSON only when you must inspect exact keyframes.

Input parameters:

- `compact` (boolean): Return a compact human-readable summary instead of the full JSON

### `fablecut_patch_project` (~3159 tokens)

Apply targeted edits to the FableCut project WITHOUT round-tripping the whole document — PREFER THIS over get+set for every edit (it is ~10-100x cheaper in tokens and merge-safe by design: it re-reads the latest document from disk, applies your ops in order, bumps revision once, saves atomically). Ops: {op:'addClip', clip:{…}} (id auto-generated if omitted) · {op:'updateClip', id, set:{…}} · {op:'removeClip', id} · {op:'addMedia', media:{…}} · {op:'removeMedia', id} · {op:'setProject', set:{name|width|height|fps|background|markers|disabledTracks|lockedTracks|untargetedTracks|encodeProfile|master}} (markers = the full list [{t, label?, color?}], color: gold|red|orange|green|cyan|blue|purple|pink; master = {gain}, the master fader in dB) · {op:'setTrack', id:'A1', set:{gain?, pan?, out?}} (audio-track fader in dB −60…+12, pan −1…1, out = a submix bus id or 'master'; null or 0 resets) · {op:'setBus', id:'B1', set:{name?, gain?, pan?, mute?}} (submix bus, created if missing; route tracks into it with setTrack out) · {op:'removeBus', id} · {op:'setFx', target:'clip'|'track'|'bus'|'master', id?, preset?:'podcast'|… OR fx:[{type,…params}], append?:true} (audio effects — validated; presets: clean-voice, podcast, radio, deep-voice, telephone, cinematic, wide, muffled; fx:null clears; on a clip it applies to its linked stems too) · {op:'setFxKeys', target, id?, index?|type?, param, keys:[{t, v, ease?}]|null} (automate one effect parameter: t is clip-local for a clip's effects, timeline seconds otherwise; see the 'Audio mix' docs section) · {op:'setGrade', id | ids:[…], grade:{exposure?, temp?, tint?, lift?, gamma?, gain?, offset?, contrast?, pivot?, blacks?, shadows?, midtones?, highlights?, whites?, lowSoft?, highSoft?, saturation?, curves?:{y?, r?, g?, b?}, hueHue?, hueSat?, hueLuma?, satLuma?, layers?:[…], on?}, replace?:true} (color grade on video / image / svg / adjust clips — wheels are [r, g, b, master]; curves are [[x, y], …] point lists on 0…1 and merge per channel;…

Input parameters:

- `baseRevision` (integer): Revision these ops were planned against. If project.json has moved past it, the patch is refused with CONFLICT (nothing saved). Omit to apply on top of the latest revision.
- `ops` (array, required): Edit operations, applied in order (see tool description for shapes). Any op may carry force:true to override a lock the user set.

### `fablecut_set_project` (~170 tokens)

Replace the FableCut project JSON. Pass the COMPLETE document (read with fablecut_get_project, modify, send back whole). Revision is auto-bumped; the open editor UI hot-reloads instantly so the user sees the edit live. CONFLICT-SAFE: if the project changed on disk since your last fablecut_get_project (e.g. the user tweaked something in the UI), the call errors instead of overwriting — re-read, re-apply your edit on top of the latest document, and retry.

Input parameters:

- `force` (boolean): Overwrite even if the project changed since it was last read (discards those external/user changes). Only when the user explicitly asks.
- `project` (object, required): The complete project document (see fablecut_docs for schema)

### `fablecut_analyze_reference` (~276 tokens)

Analyze a reference video into an EDIT BLUEPRINT so a similar edit can be rebuilt with different footage over the same music. Returns: shot boundaries (cuts) with per-shot audio energy, music beats + BPM, a loudness curve, the detected drop, and extracts the reference's music track into media/ (registered in the project, ready to place on A1). Remake recipe: copy the reference's width/height/fps to the project, write `beats` into project `markers`, lay the extracted music on A1, then place one clip per blueprint `shot` at the same start/duration — pick calm footage for low-energy shots and action for high-energy ones, and make the biggest moment land on `drop`. See the 'Remake a reference video' section of fablecut_docs.

Input parameters:

- `path` (string, required): The reference video: an absolute file path (copied into media/ automatically) or an existing '/media/…' src
- `registerMusic` (boolean): Extract the reference's music and register it as project media (default true)
- `threshold` (number): Scene-cut sensitivity 0–1 (default: adaptive 0.30→0.20→0.12). Lower it if obvious cuts are missed, raise it if too many false cuts.

### `fablecut_import_media` (~114 tokens)

Import a media file into FableCut's media library and register it in the project. Pass a local absolute path (copied, including .svg) or an https:// URL (downloaded into ./media/; video/audio/image only — remote SVG is refused). The URL is never kept as the playback src — CORS would break export. Returns the created media entry (use its id in clips).

Input parameters:

- `path` (string, required): Absolute path to a local file, or an https:// URL to download

### `fablecut_encode_profiles` (~156 tokens)

List ffmpeg encoding profiles for Fast export (from encoding-profiles.json). Each profile is a raw ffmpeg argument list plus jpegQuality, extension, and optional color (output matrix/range — default BT.709 tv). Use to pick a profile id for project.encodeProfile. Edit encoding-profiles.json on disk to add custom profiles — anything the local ffmpeg supports works, and the server hot-reloads the file. Profiles are dry-run against ffmpeg when an export starts, so a bad argument is rejected before rendering.

Input parameters:

- `detail` (boolean): Include the full ffmpeg args array per profile (default: a truncated summary)
- `profile` (string): Return one profile by id instead of the full list

### `fablecut_normalize_audio` (~259 tokens)

Loudness-normalize clips: measures each clip's source audio (ITU-R BS.1770 integrated LUFS, or sample peak) after its channel routing and sets `props.gain` (clip gain, dB) so it lands on the target — the same measurement as the editor's Normalize button. Linked stems (a video's per-channel audio clips) are measured together and get one shared gain, so a stereo pair stays balanced; passing a video clip normalizes its stems. Volume keyframes / fades are untouched (they ride on top). Typical targets: -14 LUFS streaming/social, -16 LUFS podcast/dialogue, -23 LUFS broadcast, or mode 'peak' at -1 dBFS. Needs ffmpeg + ffprobe on PATH. Refuses locked clips unless force:true.

Input parameters:

- `clipIds` (array, required): Clips to normalize (audio, or video with audio)
- `force` (boolean): Also change clips the user locked (only when they asked)
- `mode` (string): Measure integrated loudness (default) or sample peak
- `target` (number): Target level: LUFS for mode lufs (default -14), dBFS for mode peak (default -1)

### `fablecut_auto_duck` (~335 tokens)

Duck music under dialogue: finds where the voice tracks have sound (RMS above `threshold`, short gaps bridged so the music doesn't pump between words) and writes `duck` keyframes (dB) on the given music clips — a dip of `amount` dB ramping down `attack` s before speech and back up `release` s after. The duck multiplies the clip's volume, so its own level, volume keyframes and fades are untouched, and re-running replaces the previous dips (amount 0 clears them). Voice = every audio clip on `under` tracks (default: all audio tracks the music isn't on). Linked stems of a music clip get the same keys. The same pipeline as the editor's Auto-duck. Needs ffmpeg + ffprobe on PATH. Refuses locked clips unless force:true.

Input parameters:

- `amount` (number): Dip depth in dB, -40…0 (default -12; 0 removes the ducking)
- `attack` (number): Seconds to ramp down before speech (default 0.3)
- `clipIds` (array, required): The music / bed clips to duck
- `force` (boolean): Also change clips the user locked (only when they asked)
- `release` (number): Seconds to ramp back up after speech (default 0.6)
- `threshold` (number): Voice detection level in dBFS (default -40; raise it if room noise triggers ducks)
- `under` (array): Audio tracks holding the voice, e.g. ["A1"] (default: every other audio track)

### `fablecut_denoise` (~181 tokens)

Reduce background noise (hiss, hum, room tone) on audio clips: ffmpeg's FFT denoiser renders a cleaned FLAC of each clip's whole source file into media/, and the clip — with its linked stems — switches to it (the picture keeps its own file, so links and timing stay intact). The same as the inspector's Noise control. amount 'off' switches back to the original. Re-running reuses a file already rendered. Needs ffmpeg + ffprobe on PATH. Refuses locked clips unless force:true.

Input parameters:

- `amount` (string): How hard to pull the noise down (default medium); off restores the original audio
- `clipIds` (array, required): Audio clips, or video clips with linked audio stems
- `force` (boolean): Also change clips the user locked (only when they asked)

### `fablecut_export` (~330 tokens)

Render the timeline to a video file in exports/ — the editor's own Fast export (same compositor, audio mix and encoding profile as the Export button), so the file matches what the user sees. It runs in a browser: an open editor tab takes the job (the user sees the progress bar), or with no tab open the server starts headless Chrome / Edge (set FABLECUT_CHROME to pick one) and closes it afterwards. Waits for the file by default and returns its path. Range: the project's inPoint→outPoint when set, else the whole timeline (or pass range). Needs ffmpeg on PATH. One export at a time. Long edits: pass wait:false, then poll with {job}; {cancel:job} stops one.

Input parameters:

- `cancel` (string): Cancel this export job
- `job` (string): Report on an export started earlier instead of starting one
- `profile` (string): Encoding profile id (fablecut_encode_profiles); default: project.encodeProfile, else the server default
- `range` (string): Whole timeline, or the project's inPoint→outPoint (default: in-out when either is set)
- `timeout` (number): Seconds to wait before returning the job's status instead (default 900); the export keeps running
- `wait` (boolean): Block until the file is written (default true)
- `where` (string): auto (default): an open editor tab, else headless · tab: only an open tab · headless: always a background browser, leaving the user's tab alone

### `fablecut_scopes` (~363 tokens)

Measure the graded picture at one moment — what the editor's scopes show, as numbers: luma levels (min, 1st percentile, median, mean, 99th percentile, max on 0–1), the % of pixels crushed to black / clipped to white, mean R/G/B, average saturation, and the colour cast of the midtones (hue name + strength; neutral below 0.01), plus the clips on screen with their grades, masks, track mattes and blend modes. Rendered by the same compositor as export (an open editor tab, else headless Chrome / Edge), over the export frame when one is set. Use it to check a grade: e.g. a cast strength above ~0.03 on footage that should be neutral, whitePct above ~1 (clipped highlights), or a median far from ~0.4 for a normally exposed shot. The user's playhead does not move.

Input parameters:

- `mask` (object): Also measure a clip's masks: {clip}. Adds how much of that clip's picture the masks keep (coverage %, the feathered matte measured alone) and how much of the frame the masked clip covers
- `matte` (object): Also measure what one grade layer selects: {clip, layer} (layer = index into the clip's grade.layers). Adds the matte's coverage (% of that clip's picture) and the levels / colour of the selected pix…
- `time` (number): Timeline seconds to measure (default: the editor's playhead)
- `timeout` (number): Seconds to wait (default 60)
- `where` (string): auto (default): an open editor tab, else headless · tab · headless

### `fablecut_track` (~610 tokens)

Follow something in a video clip frame by frame (motion tracking, in the editor: an open tab, else headless Chrome / Edge) and store it on the clip as a named track (props.tracks). Then, in the same call, make a mask follow it (apply:{mask}) or pin another clip to it (apply:{clip} — a title, sticker, blur box… its x / y, and optionally scale / rotation, get keyframes that ride on the track, keeping where it is at `at`). What to follow: region {x, y, w, h} or point {x, y} (+ size), as fractions of the clip's picture (0…1, y down) at time `at`; or leave both out with apply:{mask} to follow what that mask covers. To re-apply an existing track, pass its name with apply and no region. Pick something with detail (a corner, a logo, text, an eye), not a flat area; the result reports match quality (≥ 0.8 is solid) and where the region was lost, if it was. Check the outcome with fablecut_scopes or by looking at the keyed clip.

Input parameters:

- `apply` (object): Bake the track into keys: {mask: index | name} (the mask's x / y — and scale / rotation when tracked — follow) or {clip: id, scale?, rotation?, at?} (that clip rides on the track)
- `at` (number): Timeline seconds where the region is as given (default: the clip's start)
- `clip` (string, required): The video clip to track in
- `direction` (string): Track from `at` to the clip's end (default), to its start, or both
- `force` (boolean): Allow changing locked clips — only when the user asked
- `name` (string): The track's name (default: the mask's name, or Track n). An existing name is extended / replaced over the tracked range
- `point` (object): A spot to follow at `at` (fractions of the picture); a square region of `size` around it is matched
- `region` (object): The area to follow at `at`: centre x, y and size w, h, fractions of the clip's picture
- `rotation` (boolean): Also follow the region's rotation
- `scale` (boolean): Also follow the region's size (zooms, objects moving closer)
- `size` (number): With point: the region's width, fraction of the picture's width (default 0.08)
- `timeout` (number): Seconds to wait (default 300)
- `to` (number): Timeline seconds to stop at (default: the clip's end / start)
- `where` (string): auto (default): an open editor tab, else headless · tab · headless

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ronak-create-fablecut/fablecut#diagnostics

## Score history

- 2026-10-17: 79
- 2026-10-16: 79
- 2026-10-15: 79
- 2026-10-14: 79
- 2026-10-13: 50
- 2026-10-12: 50

## Common questions

### What is the FableCut MCP server?

FableCut is an MCP server listed in the public MCP registry as io.github.ronak-create/fablecut. Zero-dependency browser video editor AI agents drive via a JSON timeline over MCP; ffmpeg export. This page covers its npm package (fablecut).

### Is the FableCut MCP server safe to use?

FableCut scores 79 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 17 October 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the FableCut MCP server expose?

FableCut exposes 14 tools: fablecut_status, fablecut_docs, fablecut_get_project, fablecut_patch_project, fablecut_set_project, and 9 more. Their descriptions and schemas cost roughly 6,201 tokens of context every time the server is loaded.

### Is the FableCut MCP server still maintained?

FableCut is still listed as active in the MCP registry. We last reached this channel on 17 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the FableCut MCP server under?

FableCut declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/fablecut
- Socket report: https://socket.dev/npm/package/fablecut
- Repository: https://github.com/ronak-create/FableCut
- Website: https://fablecut.space/
- Changelog RSS feed: https://verifymcp.io/servers/ronak-create-fablecut/fablecut.xml
- Changelog JSON feed: https://verifymcp.io/servers/ronak-create-fablecut/fablecut.json
- HTML version of this page: https://verifymcp.io/servers/ronak-create-fablecut/fablecut