# Scenario Video Editing

> Use when editing footage already on Scenario through MCP with a tool model, not a new generation: LUT grading, color correction, grain, vignette, blur, sharpen, glow, tint, desaturate, posterize, solarize, oilify, cubism, chromatic aberration, dodge and burn on a clip; trimming, splitting, reversing, resizing, re-encoding, frame extraction, image sequences; chroma key, green or blue screen removal to transparent WebM or ProRes MOV, background removal, segmentation masks, subjects as layers.

- Skill: `scenario-labs/scenario-video-editing` (Agent Skill)
- Install (CLI): `npx get-skill add scenario-labs/scenario-video-editing`
- Raw SKILL.md: https://api.skillmd.com/api/skills/scenario-labs/scenario-video-editing/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: scenario-labs (https://skillmd.com/u/scenario-labs)
- Updated: 2026-11-11
- Page: https://skillmd.com/skills/scenario-labs/scenario-video-editing

---


# Scenario Video Editing

## Overview

Every image post-processing effect has a video twin, and each is a `model_run` on a tool model: one
clip in, a few numbers, one clip out. Generating or restyling footage, lipsync, dubbing and
upscaling are `scenario-video`; concatenating, compositing and captioning a cut are
`scenario-video-assembly`; the still-image side is `scenario-image-editing`. Connection and the core
loop: `scenario`. If a sibling skill named here is missing from your available skills, load it with
`skill_get` (Scenario MCP) or ask the user to install it
(https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag
the gap.

## The twin rule

A video effect's id is the image id with `-video` appended, its file field is `video` rather than
`image`, and the knobs are identical: `model_scenario-postprocessing-lut-video` takes the same
`lutStyle` enum and `lutIntensity` as `model_scenario-postprocessing-lut`. All eighteen have twins,
from blur and color correction through oilify, posterize and vignette.

One twin differs: Dissolve (Video) blends the clip with a still `dissolveImage`, not a second clip;
crossfading two clips is a concat transition.

## Quick reference

| Need                  | Model or query                                                           |
| --------------------- | ------------------------------------------------------------------------ |
| Grade or stylize      | `filters={"tags": ["Post Processing"]}`, plus the effect name as `query` |
| Trim to a range       | `model_scenario-video-cut` (`startTime`, `endTime`)                      |
| Cut into segments     | `model_scenario-video-split` (`cutPoints`; N points give N+1 clips)      |
| Rescale or re-encode  | `model_scenario-resize-video`                                            |
| Play a clip backwards | `model_reverse-video`                                                    |
| Frames out, frames in | `model_scenario-video-to-image-seq`, `model_scenario-image-seq-to-video` |
| Subjects as layers    | `model_scenario-video-layers-extractor`                                  |
| Masks, cutouts        | `recommend` with the need in the user's own words                        |
| Key a green screen    | `model_scenario-video-chroma-key`                                        |
| Pull the audio track  | `model_scenario-audio-extract`                                           |

Extracted frames carry no index and share one `createdAt`, so their order exists only in the job
row's `assetIds`, and that list has come back out of time order (a confirmed defect at authoring
time). The extractor takes a scalar `video`; every frame is `extractAllFrames: true`, and
`frameInterval` (default 24 at authoring time, about one frame a second on a 24 fps clip) applies
only when that flag is off. Check the row's length: exactly the clip's `nbFrames` ids with the flag
on, about `nbFrames` / `frameInterval` with it off, sampled from frame 0 (`asset_get` reports
`nbFrames` beside `frameRate`; a short row is a dropped frame, which no reordering fixes), then,
before reassembling with `model_scenario-image-seq-to-video` or handing frames on, lay the returned
ids into `model_scenario-grid-maker` in that order (a fixed first-party id: Scenario's single grid
tool; its `images` field takes an array of 1 to 100 ids and ignores a bare id while the run still
succeeds, so past 100 frames sheet in batches or raise `frameInterval`; set `columns`, default 3 and
up to 20, so a batch reads as a near-square sheet) and read the sheet with `asset_display`, not a
download (it tiles frames at source resolution, so the file can pass 100 MB), against the clip's
free `firstFrame` and `lastFrame` and its motion; a frame that breaks continuity is out of place,
and the corrected order travels as your own id list from then on. Never rebuild order from listings
or timestamps, and a preview that runs backwards on a clean sheet is the assembler's `pingpong`
flag, not the order.

A cutout with transparency never ships as mp4: at authoring time the removal models carried alpha
only as WebM or ProRes 4444 MOV, so read the output-format enum off `model_schema_get` and agree the
container with the user before pricing the run.

Effect lookups go through `search`, `target="models"`, `public=true`. The `model_scenario-` ids are
constants: each is Scenario's single deterministic tool for its operation, so discovery would only
re-derive it. `model_reverse-video` sits outside that set and is an authoring-time hit: re-discover
it by name (`search` `query="video reverse"`).

## Keying a green or blue screen

Footage shot or generated on a solid screen goes to `model_scenario-video-chroma-key`, a fixed
first-party id: Scenario's single chroma-key tool. Footage with no solid screen is a segmentation
job instead (the Masks, cutouts row).

- Leave `keyColor` empty: the tool detects the green or blue screen from the borders of the first
  frames. Set a hex only when detection keys the wrong color.
- `outputFormat` decides the alpha: `webm` (VP9 with alpha, the default) for web and engines, `mov`
  (ProRes 4444 with alpha) for editing and compositing apps. `mp4` carries no alpha and requires
  `backgroundColor`, a solid color composited behind the subject.
- Edges take five controls, read with `model_schema_get`: a green fringe or halo on hair and edges
  wants `spillSuppression` (default 1, the maximum, at authoring time) and a positive `edgeShrink`
  of 1 to 2 pixels; holes in the subject want a lower `tolerance` (default 0.3); a hard, stepped
  edge wants `softness` or `edgeFeather`.
- The input is capped (60 seconds at authoring time, `max_duration` in the schema): trim first.
- Generating footage to key: ask the video model for a flat, evenly lit pure green background, no
  shadows on it, and a subject wearing no green. Motion blur and fine hair key worst, so judge those
  frames first.

## Cost follows the clip, so trim first

On the video twins the `video` input carries `cost_impact: true`, which the image versions do not:
price tracks the footage rather than the settings. Trim to the frames that ship, then grade;
`dry_run=true` prices a payload before it runs. Video tools also outlast `model_run`'s wait window,
so launch with `wait=false` and follow with `jobs_wait`, re-calling it with the returned
`pending_job_ids`. A client-side timeout on `jobs_wait` is as harmless as the server's own: re-call
it with the same ids rather than treating the job as lost.

Checking costs nothing: `asset_get` returns `firstFrame` and `lastFrame` as their own asset ids, so
`asset_display` one to confirm a grade before chaining another billable run onto it.

## Field names drift between neighbors

- Video Cut and the effect twins take a scalar `video`. Resize Video takes `video` as an
  `array: true` field capped at one item, where a bare id is dropped silently; its size is `width`
  and `height` in pixels, both optional, and one alone keeps the aspect ratio.
- The output format field is `outputFormat` on cut and split, `videoOutputFormat` on resize.
- `preserveAudio` defaults to true on cut, split and resize; the effects expose no audio field and
  pass the track through.
- Enum values are copied, not retyped: one `lutStyle` string contains a space.
- `asset_download` takes no `format` for a video: it converts image formats only. A GIF from the
  sequence tool is an image asset and takes `format: "gif"`; the `png` default flattens it to one
  frame.

## Resizing is not reframing

No tool model repaints a video's canvas. Resize Video takes `fit`: `contain` (default) fits the clip
inside the target, `stretch` forces the size and distorts, `cover` fills the target and center-crops
the rest. `cover` is the cheap way to an exact ratio when losing the edges is acceptable, but none
of them gives a 16:9 clip a vertical frame with the whole picture kept, so that brief needs a
decision before any spend, between two routes an order of magnitude apart in price.

- **Generative reframe** (`query="reframe"`, Luma Ray 3.2 Reframe and Wan 2.2 Reframe,
  `scenario-video` territory) outpaints past the frame and keeps the whole picture, at by far the
  highest price in such a job. Resolution ceilings bite: a schema can allow a vertical ratio and its
  top resolution tier separately yet reject the pair at run time.
- **Compositor** (Video Studio, cropping or pillarboxing onto a vertical canvas) is cheap but throws
  away width or adds bars, and its layer geometry is `scenario-video-assembly`'s contract rather
  than a one-line setting.

`dry_run` prices a payload without validating it, so either route can bill for a run that fails
outright or returns a mis-composed frame at exactly the right dimensions.

## Reworking a finished video

A request to reorder, drop, or lengthen shots in a video already rendered is an edit, not a new
generation. Regenerate only the shot whose content must change.

1. With a music bed, pull it first: `model_scenario-audio-extract` on the master, before any split
   chops it.
2. Find the shot boundaries. `asset_get` the master for `nbFrames` and `frameRate`. Extract frames
   at the shortest `frameInterval` that keeps the clip on one sheet (`nbFrames` / 100, rounded up),
   and verify their order as above (count, sheet with the ids as an `images` array, correct against
   continuity). Each cut is a jump between neighbors in the corrected order. Its time is the 0-based
   position of the new shot's first frame × `frameInterval` / `frameRate`, accurate to one stride.
3. `model_scenario-video-split` with those times as `cutPoints` (an array, sorted, in seconds; N
   points give N+1 segments) and `video` as a scalar.
4. Confirm each segment before reordering: `asset_get` its `duration` and `asset_display` its
   `firstFrame`. Never take the row's id order as the timeline order.
5. Rebuild with one `model_scenario-video-concat`, `videos` holding every kept segment in the new
   order (2 to 50 ids). Hard cuts are the default; `transitions` holds one entry per seam.
   - **Reorder or drop**: list the segments in the new order and leave out any dropped shot.
   - **Lengthen a shot**: no tool model retimes or slows a clip. Extend it from its `lastFrame` with
     a video model (the last-frame chain in `scenario-video`) and list the extension right after
     that shot.
   - **Change what a shot shows**: regenerate that shot alone in `scenario-video` and list it in the
     shot's slot.
6. Check sync on the result: concat has drifted audio against picture (see
   `scenario-video-assembly`). Lay the extracted bed back over the rebuilt cut there, trimmed to its
   new length.

## Worked example: a graded cutdown

Launch every `model_run` below with `wait=false` and retire it with `jobs_wait` before the next step
reads its asset.

1. `asset_get` the master and read `properties.duration` before choosing times.
2. Trim: `model_scenario-video-cut` with `startTime` and `endTime` in seconds. Going first is what
   makes every later step cheaper.
3. Reshape: `model_scenario-resize-video`, `video` as a one-item array, `width` and `height` at the
   delivery size, `videoOutputFormat: "mp4"`. `fit` settles the shape at this step rather than
   later: `cover` lands an exact ratio once the edges are spendable, and a shape that has to keep
   the whole picture is the reframe decision above.
4. Grade: `model_schema_get`, then the LUT twin with `lutIntensity` near 0.6.
5. Texture: `model_schema_get`, then the Grain twin with `grainProfile` (a 22-value enum, default
   `kodak_portra_400` at authoring time) on that output, last, so its grain is sized for the
   delivered frame rather than resampled by a later resize.
6. `asset_display` the result's `firstFrame` to confirm the look, then `asset_download` with no
   `format`.

## Common mistakes

- Grading each source clip and then concatenating: grade the finished master once, or the shots
  drift apart.
- Reaching for local ffmpeg, or for an MCP tool named `video_edit`: the surface is `model_run` on
  tool models.
- Polling `job_get` in a loop instead of `jobs_wait`, whose timeout is not an error.
- Trusting a Grain profile to add grain: the 22 profiles are looks, not intensities, and some soften
  the picture instead. Compare a frame against the input.

