LABSCO SUMMARY

Typed video operations with a receipt, so a render can be re-run and checked rather than trusted.

The tool list covers the everyday FFmpeg jobs, but what makes it worth wiring up is the frame around them: preflight validation before a render, a receipt carrying per-step input and output hashes after it, and quality gates that fail closed instead of publishing something broken. It all runs on your machine against local files — nothing is uploaded, and raw .insv or GoPro .360 files are rejected rather than half-handled.

What it is

Kinocut — formerly mcp-video — is a local-first video editing server over FFmpeg. Every operation is a typed tool with preflight validation, and each render answers with a Video Receipt recording input and output hashes, so the edit can be re-run and reviewed rather than taken on trust.

What you get

The ordinary cutting work: video_trim by timestamp, video_merge with optional xfade transitions, video_resize, video_crop, video_rotate, video_convert, video_overlay
Captions end to end — video_ai_transcribe for speech to text, video_subtitles to burn a subtitle file in, video_translate_captions for a second language
Shorts and Reels packaging: video_repurpose_plan, video_repurpose, shorts_render, shorts_package
Checks before publish — video_quality_check, video_release_checkpoint, video_review_run, video_review_decide
A job-spec workflow engine: video_workflow_validate, video_workflow_plan, video_workflow_render, video_workflow_inspect, with a resume cursor and per-step hashes in the receipt
Repair that leaves the story and timeline alone — video_rescue_plan, video_rescue_render, video_rescue_inspect
Stills treated as media in their own right: still_match, still_grade, still_gate, image_extract_colors, image_generate_palette
360 dual-cam assembly from a stitched equirect MP4, driven through video_intent and video_review_decide

Requirements

FFmpeg on PATH — without it nothing runs; brew install ffmpeg or sudo apt install ffmpeg. Python 3.11 or newer. No account and no key: the published package is kinocut on PyPI, run as uvx --from kinocut kino over stdio or installed with pip install kinocut. Whisper transcription, image analysis, stem separation and upscaling are optional extras — pip install "kinocut[transcribe]" and its siblings — and kino doctor reports which are present and what is missing. Hyperframes tools additionally want Node.js 22+ and the Hyperframes CLI on PATH.

Setup effort

One command — uvx --from kinocut kino

See installation options

USE CASES

Turning an interview into a captioned vertical clip

Cut the segment, transcribe it, burn the captions in, then reframe to 9:16.

video_trimvideo_ai_transcribevideo_subtitlesvideo_resize

Deciding whether an export is fit to publish

Run the quality gate and produce a release checkpoint with a thumbnail, instead of eyeballing the file.

video_quality_checkvideo_release_checkpoint

Repeating the same edit on next week's recording

Validate the job spec, plan the op graph without rendering, then render and keep the receipt.

video_workflow_validatevideo_workflow_planvideo_workflow_render

Fixing a clip without changing the cut

Read the diagnosis, approve only the repairs you want, then inspect the verified package.

video_rescue_planvideo_rescue_rendervideo_rescue_inspect

Cutting one recording into platform packages

Plan the repurpose, render the shorts, then package them with their manifests.

video_repurpose_planshorts_rendershorts_package

194 tools

Counted once with only startup setup. Other versions, modes or optional credentials may expose a different list.

`audio_compose`

Layer multiple audio tracks with volume mixing.

Mix multiple WAV files together with individual volume control.

Args: tracks: List of track configs with:

file: Absolute path to WAV file
volume: Volume multiplier 0-1
start: Start time offset in seconds
loop: Whether to loop the track (default false) duration: Total output duration in seconds. output_path: Absolute path for the output WAV file.

Returns: Dict with success status and output_path.

`video_workflow_render`

Execute an agent workflow job-spec and return a provenance receipt.

Validates the spec first (fail-closed), then runs each allowlisted op (probe|trim|resize|convert|merge|add_text|composite_layers) SEQUENTIALLY in spec order via the backing engine functions. Intermediates are written to a per-run `@work directory unique to this invocation and cleaned on success (kept on failure); final media lands at the declared @outputs` paths.

Batch variants: pass `variant=<id> to render one declared variant (its overrides patch the shared steps/outputs, and the single @outputs path is auto-named with the variant id so N variants emit N distinct outputs); the receipt records workflow.variant. Pass all_variants=True to render EVERY declared variant in turn and return a workflow_batch summary (one receipt per variant, each into its own @work dir); use save_receipt_dir to also write each variant's receipt to <dir>/<variant>.json. variant and all_variants are mutually exclusive. Pass keep_intermediates=True to retain @work intermediates even on success (recorded as the keep-intermediates` cleanup policy).

Pass `resume_receipt (a prior render receipt from a job that failed with its intermediates kept) to RESUME: the current spec_hash must equal the receipt's (else fail-closed resume_spec_mismatch) AND, for a variant, the receipt's variant must match (else resume_variant_mismatch); each step whose recorded status is completed` AND whose recorded input hashes still match AND whose recorded output file still exists and re-hashes to the recorded hash is SKIPPED, and the first step failing any check plus everything after it re-runs.

Returns a workflow receipt (`receipt_kind: "workflow") capturing tool + FFmpeg versions, the spec hash, per-source probes/hashes, per-step status with real sha256 hashes of every consumed input and produced output, the cleanup manifest, and the determinism-scope caveat. On the first failing step it fails closed: the failure is recorded on the receipt (still written to save_receipt` when given) and surfaced as a structured error.

Args: spec_path: Absolute path to the workflow job-spec JSON file. resume_receipt: Optional path to a prior render receipt to resume from. save_receipt: Optional path to write the workflow receipt as JSON. keep_intermediates: Retain @work intermediates even on success. variant: Optional declared variant id to render a single variant. all_variants: Render every declared variant and return a batch summary. save_receipt_dir: With all_variants, directory for per-variant receipts.

INSTALLATION

Connect your client

Server setup

TERMINAL

uvx --from kinocut kino

MCP Clients

Claude Code

CLAUDE CODE · TERMINAL

claude mcp add kinocut -- uvx --from kinocut kino

Claude Desktop, Cursor

JSON

{
  "mcpServers": {
    "kinocut": {
      "command": "uvx",
      "args": [
        "--from",
        "kinocut",
        "kino"
      ]
    }
  }
}

FFmpeg Video Editing

Typed video operations with a receipt, so a render can be re-run and checked rather than trusted.

What it is

What you get

Requirements

Setup effort

Turning an interview into a captioned vertical clip

Deciding whether an export is fit to publish

Repeating the same edit on next week's recording

Fixing a clip without changing the cut

Cutting one recording into platform packages

194 tools

audio_compose

audio_effects

audio_preset

audio_sequence

audio_synthesize

effect_chromatic_aberration

effect_glow

effect_noise

effect_scanlines

effect_vignette

glitch_cmyk_split

glitch_datamoshing

glitch_depth_splatting

glitch_digital_feedback

glitch_macroblocking

glitch_point_cloud

glitch_rgb_shift

glitch_scanline_jitter

glitch_screen_tearing

glitch_slit_scan

glitch_turbulent_displacement

glitch_vhs_tracking

hyperframes_add_block

hyperframes_benchmark

hyperframes_capture

hyperframes_catalog

hyperframes_compositions

hyperframes_doctor

hyperframes_info

hyperframes_init

hyperframes_inspect

hyperframes_preview

hyperframes_remove_background

hyperframes_render

hyperframes_snapshot

hyperframes_still

hyperframes_to_mcpvideo

hyperframes_transcribe

hyperframes_tts

hyperframes_validate

image_analyze_product

image_edit

image_extract_colors

image_generate_palette

search_tools

shorts_package

shorts_plan_show

shorts_render

shorts_review

shot_prompt_render

sound_capabilities

sound_mix_render

sound_plan_validate

sound_qa_asr

sound_qa_loudness

sound_voice_batch

still_gate

still_grade

still_match

still_package

storyboard_read

style_pack_read

transition_glitch

transition_morph

transition_pixelate

video_acceptance_eval

video_add_audio

video_add_generated_audio

`audio_compose`

`audio_effects`

`audio_preset`

`audio_sequence`

`audio_synthesize`

`effect_chromatic_aberration`

`effect_glow`

`effect_noise`

`effect_scanlines`

`effect_vignette`

`glitch_cmyk_split`

`glitch_datamoshing`

`glitch_depth_splatting`

`glitch_digital_feedback`

`glitch_macroblocking`

`glitch_point_cloud`

`glitch_rgb_shift`

`glitch_scanline_jitter`

`glitch_screen_tearing`

`glitch_slit_scan`

`glitch_turbulent_displacement`

`glitch_vhs_tracking`

`hyperframes_add_block`

`hyperframes_benchmark`

`hyperframes_capture`

`hyperframes_catalog`

`hyperframes_compositions`

`hyperframes_doctor`

`hyperframes_info`

`hyperframes_init`

`hyperframes_inspect`

`hyperframes_preview`

`hyperframes_remove_background`

`hyperframes_render`

`hyperframes_snapshot`

`hyperframes_still`

`hyperframes_to_mcpvideo`

`hyperframes_transcribe`

`hyperframes_tts`

`hyperframes_validate`

`image_analyze_product`

`image_edit`

`image_extract_colors`

`image_generate_palette`

`search_tools`

`shorts_package`

`shorts_plan_show`

`shorts_render`

`shorts_review`

`shot_prompt_render`

`sound_capabilities`

`sound_mix_render`

`sound_plan_validate`

`sound_qa_asr`

`sound_qa_loudness`

`sound_voice_batch`

`still_gate`

`still_grade`

`still_match`

`still_package`

`storyboard_read`

`style_pack_read`

`transition_glitch`

`transition_morph`

`transition_pixelate`

`video_acceptance_eval`

`video_add_audio`

`video_add_generated_audio`

`video_add_text`

`video_add_texts`

`video_ai_color_grade`

`video_ai_remove_silence`

`video_ai_scene_detect`

`video_ai_stem_separation`

`video_ai_transcribe`

`video_ai_upscale`

`video_analyze`

`video_apply_mask`

`video_audio_bed`

`video_audio_spatial`