# Kinocut (pypi · kinocut)

Guardrailed video editing for AI agents: FFmpeg, captions, effects, Hyperframes, and receipts.

- Trust score: 62/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `kinocut`: 62/100 (this document), [markdown](https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut.md), [page](https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut)

## Channel facts

- Registry: `pypi`
- Package: `kinocut`
- Version: `1.16.5`
- 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-11-05.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 35 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to KyaniteLabs/kinocut).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 8 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 57/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3508 tokens (~175/item across 20 items; 20 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 check failed: the tool surface changed between 1.16.2 and 1.16.5: 185 tool removals, 0 breaking changes, 2 additions.
- **Tool Coverage**: 84/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 42% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 21 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.

## Install

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

Kinocut runs locally as a PyPI package, launched with uvx kinocut. 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 tech-kyanitelabs-kinocut -- uvx kinocut
```

### Cursor

```json
{
  "mcpServers": {
    "tech-kyanitelabs-kinocut": {
      "command": "uvx",
      "args": [
        "kinocut"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "tech-kyanitelabs-kinocut": {
      "command": "uvx",
      "args": [
        "kinocut"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add tech-kyanitelabs-kinocut -- uvx kinocut
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tech-kyanitelabs-kinocut": {
      "type": "local",
      "command": [
        "uvx",
        "kinocut"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add tech-kyanitelabs-kinocut --command uvx --arg kinocut
```

### Hermes

```yaml
mcp_servers:
  tech-kyanitelabs-kinocut:
    command: "uvx"
    args: ["kinocut"]
```

### Netclaw

```json
{
  "McpServers": {
    "tech-kyanitelabs-kinocut": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "kinocut"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add tech-kyanitelabs-kinocut -t stdio -c uvx -a kinocut
```

### Other

```json
{
  "mcpServers": {
    "tech-kyanitelabs-kinocut": {
      "command": "uvx",
      "args": [
        "kinocut"
      ]
    }
  }
}
```

## 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-11-05 (score 62, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-31 (score 77, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-27 (score 62, −3)

- [security regression] Stability: 0.17 → fail
- [functional regression] Schema quality: 130 → 175
- [functional improvement] Tool coverage: 25% → 42%
- [functional] Schema quality: fair → good
- [functional] Destructive annotations: All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
- [functional] Package version: 1.16.4 → 1.16.5

### 2026-10-25 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-24 (score 64, 0)

- [functional] Package version: 1.16.3 → 1.16.4

### 2026-10-23 (score 64, +1)

- [functional regression] Schema quality: 110 → 129
- [functional improvement] Tool coverage: 6% → 25%
- [functional improvement] Stability: unverified → 0.07
- [functional] Schema quality: good → fair
- [functional] Package version: 1.16.2 → 1.16.3

### 2026-10-21 (score 63)

First indexed and scored.

## MCP tools (20)

### `video_info` (~172 tokens)

Probe a video file for metadata. Returns JSON {success, info:{duration, resolution, codec, fps, size, ...}}. Use before any edit to learn the source's dimensions and length. Pass input_path as the absolute path to the existing video. Set exact=true to also get the decoded frame_count and the raw r_frame_rate/avg_frame_rate strings (slower: the whole video stream is decoded).

Args:
    input_path: Absolute path to the video file.
    exact: Also report frame_count (decoded), frame_count_source, r_frame_rate and avg_frame_rate (raw ffprobe strings, null when not measurable).

Input parameters:

- `exact` (boolean)
- `input_path` (string, required)
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.

### `video_trim` (~254 tokens)

Trim a video clip by start time and duration. Returns JSON {success, output_path} pointing at the rendered clip. Use to cut a segment out of a longer video. Pass input_path as the absolute path to the source video (e.g. from video_info), start as a timestamp, and duration or end to define the segment.

Args:
    input_path: Absolute path to the input video.
    start: Start timestamp (e.g. '00:02:15') or numeric seconds (e.g. 10.5).
    duration: Duration to keep (e.g. '00:00:30' or '30'). Exclusive with end.
    end: End timestamp. Exclusive with duration.
    output_path: Where to save the trimmed video. Auto-generated if omitted.
    accurate: Frame-accurate seeking (slower).  Default False uses fast
        input seeking which may land on the nearest keyframe.

Input parameters:

- `accurate` (boolean)
- `duration`
- `end`
- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `start`

### `video_merge` (~205 tokens)

Merge video clips

Concatenate two or more existing video clips into one rendered output file. Returns JSON {success, output_path}. Use to join ordered clips into a single video. Pass clips as an ordered list of absolute paths (at least two); output is auto-named or written to output_path.

Input parameters:

- `clips` (array, required): Ordered absolute paths to existing video clips. Provide at least two clips; inputs are validated and never modified.
- `output_path`: Destination video path. Auto-generated when omitted; an existing supplied path may be overwritten.
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `transition`: Optional xfade transition applied to every clip boundary, such as fade, dissolve, wipeleft, wiperight, slideleft, or slideright.
- `transition_duration` (number): Duration in seconds for each transition; must fit inside neighboring clips.
- `transitions`: Optional per-boundary xfade transitions. Overrides transition when provided.

### `video_add_text` (~374 tokens)

Overlay text on a video (titles, captions, watermarks). Returns JSON {success, output_path}. Use to burn a single text element into a video. Pass input_path as the source video, text with the string to draw, and position/size/color to style it; output_path is auto-named when omitted.

Args:
    input_path: Absolute path to the input video.
    text: Text to overlay.
    position: Position on screen. Named (top-left, top-center, etc.), pixel"
              " {"x": 100, "y": 50}, or percentage {"x_pct": 0.5, "y_pct": 0.5}.
    font: Path to font file. Uses system default if omitted.
    size: Font size in pixels.
    color: Text color (CSS color name or hex).
    shadow: Add text shadow for readability.
    start_time: When the text appears (seconds). Null = always visible.
    duration: How long text is visible (seconds). Requires start_time.
    output_path: Where to save the output. Auto-generated if omitted.
    crf: Override CRF value (0-51, lower = better quality). Default 23.
    preset: Override FFmpeg encoding preset (ultrafast, fast, medium, slow, veryslow).

Input parameters:

- `color` (string)
- `crf`
- `duration`
- `font`
- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `position`
- `preset`
- `shadow` (boolean)
- `size` (integer)
- `start_time`
- `text` (string, required)

### `video_add_texts` (~310 tokens)

Overlay multiple text elements on a video in a single FFmpeg pass.

Returns JSON {success, output_path}. Use when one video needs several captions at once.
Pass input_path as the source video and texts as a list of overlay dicts (text plus optional position/size/color/timing).

Args:
    input_path: Absolute path to the input video.
    texts: List of text overlay dicts. Each dict may contain:
        - text (str, required)
        - position (str|dict, default "center")
        - font (str, optional)
        - size (int, default 48)
        - color (str, default "white")
        - shadow (bool, default True)
        - start_time (float, optional)
        - duration (float, optional)
    output_path: Where to save the output. Auto-generated if omitted.
    crf: Override CRF value (0-51, lower = better quality). Default 23.
    preset: Override FFmpeg encoding preset (ultrafast, fast, medium, slow, veryslow).
    auto_layout: Automatically distribute vertically stacked texts at the
        same named position. Default True.

Input parameters:

- `auto_layout` (boolean)
- `crf`
- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `preset`
- `texts` (array, required)

### `video_add_audio` (~326 tokens)

Add or mix video audio

Add, replace, or mix an audio track into an existing video and render a new output file. Returns JSON {success, output_path}. Use to score or re-voice a video; source video and audio are read only. Pass video_path as the source video and audio_path as the audio file; set mix to combine or false to replace.

Input parameters:

- `audio_path` (string, required): Absolute path to an existing local audio file such as MP3, WAV, M4A, or AAC.
- `duration_policy` (string): How to reconcile audio and video length: keep_video (default, preserves the full video/outro), pad_audio, loop_audio, trim_audio, or shortest (may trim the outro).
- `fade_in` (number): Non-negative fade-in duration in seconds applied to the inserted audio.
- `fade_out` (number): Non-negative fade-out duration in seconds applied near the inserted audio end.
- `mix` (boolean): True mixes the new audio with existing video audio; false replaces the original audio track.
- `output_path`: Destination video path. Auto-generated when omitted; an existing supplied path may be overwritten.
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `start_time`: Optional start offset in seconds where the inserted audio begins.
- `video_path` (string, required): Absolute path to an existing local video file. The input file is read only.
- `volume` (number): Audio gain from 0.0 to 2.0, where 1.0 preserves original loudness.

### `video_resize` (~232 tokens)

Resize a video or change its aspect ratio. Returns JSON {success, output_path}. Use to fit a video to target dimensions or a preset ratio. Pass input_path as the source video (e.g. from video_info) and either width/height or aspect_ratio to define the target.

Args:
    input_path: Absolute path to the input video.
    width: Target width in pixels. Use with height.
    height: Target height in pixels. Use with width.
    aspect_ratio: Preset aspect ratio (16:9, 9:16, 1:1, 4:3, 4:5, 21:9). Overrides width/height.
    quality: Quality preset (low, medium, high, ultra).
    output_path: Where to save the output. Auto-generated if omitted.

Input parameters:

- `aspect_ratio`
- `height`
- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `quality` (string)
- `width`

### `video_convert` (~200 tokens)

Convert video format

Transcode a video into a different container or codec (mp4, webm, gif, mov, ...). Returns JSON {success, output_path}. Use for format conversion; prefer video_export for delivery presets. Pass input_path as the source video and format as the target container; long renders stream MCP progress.

Input parameters:

- `format` (string): Target output format: mp4, webm, gif, mov, hevc, av1, or prores.
- `input_path` (string, required): Absolute path to an existing local video file. The input file is read only.
- `output_path`: Destination video path. Auto-generated when omitted; an existing supplied path may be overwritten.
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `quality` (string): Encoding quality preset: low, medium, high, or ultra.
- `target_bitrate`
- `two_pass` (boolean)

### `video_speed` (~168 tokens)

Change video speed

Render a new video with playback speed changed; the source video is left unchanged. Returns JSON {success, output_path}. Use for slow-motion or fast-forward effects. Pass input_path as the source video and factor as the multiplier (below 1.0 slows, above 1.0 speeds up).

Input parameters:

- `factor` (number): Playback speed multiplier. 2.0 is double speed, 0.5 is half speed, and 1.0 is unchanged.
- `input_path` (string, required): Absolute path to an existing local video file. The input file is read only.
- `output_path`: Destination video path. Auto-generated when omitted; an existing supplied path may be overwritten.
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.

### `search_tools` (~167 tokens)

Find registered MCP tools by name, keyword, or a supported task phrase.

Returns JSON {success, query, count, tools:[{name, description, required_params}]}.
Use to find the right tool for a task without reading every description. Pass query
with a term such as blur, resize, subtitle, audio, or trim, or a task such as
"remove filler words", "resume render", or "keep face in frame". Exact names
rank first. Discovery describes contracts, not installed backend availability.

Args:
    query: Search term — e.g. "blur", "resize", "subtitle", "audio", "trim".

Input parameters:

- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `query` (string, required)

### `video_quality_check` (~100 tokens)

Run visual quality checks on a video.

Analyzes brightness, contrast, saturation, audio levels,
and color balance. Returns quality scores and recommendations.

Args:
    input_path: Absolute path to video file
    fail_on_warning: If True, treat warnings as failures

Input parameters:

- `fail_on_warning` (boolean)
- `input_path` (string, required)
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.

### `video_project_create` (~95 tokens)

Scaffold a cinematic video project with style, storyboard, and refs folders.

Args:
    slug: Project slug using lowercase letters, numbers, hyphens, or underscores.
    output_dir: Base directory for the projects/ folder. Defaults to the current working directory.

Input parameters:

- `output_dir`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `slug` (string, required)

### `video_doctor` (~42 tokens)

Return a read-only JSON readiness verdict for the next video job.

Input parameters:

- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.

### `video_validate_text_layout` (~170 tokens)

Validate a set of text overlays for visual failure modes before rendering.

Checks for: text overlap, low contrast, unsafe positioning, excessive
sequential overlays, and missing shadows.

Args:
    overlays: List of overlay specs with keys: text, position, size, color,
              shadow (optional), start_time (optional), duration (optional).
    video_width: Video width in pixels.
    video_height: Video height in pixels.
    background_color: Background hex color for contrast checking.

Returns:
    dict with warnings list and clean boolean.

Input parameters:

- `background_color` (string)
- `overlays` (array, required)
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `video_height` (integer)
- `video_width` (integer)

### `video_extract_frame` (~135 tokens)

Extract a frame using the same sampling as CLI and Python frame extraction.

Omitted timestamps use smart thumbnail selection when available, falling
back to 10% of the clip duration. Pass 0 explicitly to extract the first frame.

Args:
    input_path: Absolute path to the video.
    timestamp: Explicit time in seconds, or None for automatic sampling.
    output_path: Where to save the frame. Auto-generated if omitted.

Input parameters:

- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `timestamp`

### `hyperframes_doctor` (~36 tokens)

Run Hyperframes environment diagnostics.

Input parameters:

- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.

### `video_review_package` (~67 tokens)

Assemble a review package and publish-gate verdict for a candidate artifact.

Input parameters:

- `blocking_findings`
- `candidate_artifact` (string, required)
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `project_dir` (string, required)

### `video_rescue_inspect` (~50 tokens)

Inspect a rescue plan or receipt and re-check artifact integrity.

Input parameters:

- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `receipt` (string, required)

### `video_shorts` (~70 tokens)

Trim, caption, make vertical, and export selected segments in one call.

Input parameters:

- `input_path` (string, required)
- `output_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `segments` (array, required)
- `style`

### `video_workflow_inspect` (~262 tokens)

Summarize any receipt this project emits, with a read-only integrity check.

Reads a workflow render receipt, a dry-run ``workflow_plan`` artifact, or a
\``layer_plan`` receipt (v1 legacy with NO ``receipt_kind`` field, or v2) at
\``receipt_path`` and returns a NORMALIZED inspection: the kind (inferred from
the ``tool`` field when ``receipt_kind`` is absent, per legacy tolerance),
schema_version, tool, versions, a status summary (per-step statuses, failed
step + error if any), a hash presence/integrity report (which recorded
source/output hashes still match the bytes on disk NOW — a read-only re-check),
outputs, warnings, cleanup state, plus human-review pointers and known
limitations.

Nothing is rendered or modified. A malformed/unreadable receipt fails closed
with ``invalid_workflow_receipt``.

Args:
    receipt_path: Absolute path to the receipt JSON file to inspect.
    compare_path: Optional second receipt; when set, also return a diff (N3).

Input parameters:

- `compare_path`
- `overwrite` (boolean): Explicitly allow replacing existing media. Existing non-media files are protected.
- `receipt_path` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut#diagnostics

## Score history

- 2026-11-05: 62
- 2026-11-04: 77
- 2026-11-03: 77
- 2026-11-02: 77
- 2026-11-01: 77
- 2026-10-31: 77
- 2026-10-30: 62
- 2026-10-29: 62
- 2026-10-28: 62
- 2026-10-27: 62
- 2026-10-26: 65
- 2026-10-25: 65
- 2026-10-24: 64
- 2026-10-23: 64
- 2026-10-22: 63
- 2026-10-21: 63

## Common questions

### What is the Kinocut MCP server?

Kinocut is an MCP server listed in the public MCP registry as tech.kyanitelabs/kinocut. Guardrailed video editing for AI agents: FFmpeg, captions, effects, Hyperframes, and receipts. This page covers its PyPI package (kinocut).

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

Kinocut scores 62 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. 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 Kinocut MCP server expose?

Kinocut exposes 20 tools: video_info, video_trim, video_merge, video_add_text, video_add_texts, and 15 more. Their descriptions and schemas cost roughly 3,435 tokens of context every time the server is loaded.

### Is the Kinocut MCP server still maintained?

Kinocut is still listed as active in the MCP registry. We last reached this channel on 5 November 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 Kinocut MCP server under?

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

## Links

- PyPI project: https://pypi.org/project/kinocut/
- Socket report: https://socket.dev/pypi/package/kinocut
- Repository: https://github.com/KyaniteLabs/kinocut
- Website: https://kinocut.dev/
- Changelog RSS feed: https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut.xml
- Changelog JSON feed: https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut.json
- HTML version of this page: https://verifymcp.io/servers/tech-kyanitelabs-kinocut/kinocut