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.
- With a music bed, pull it first:
model_scenario-audio-extract on the master, before any split
chops it.
- 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.
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.
- 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.
- 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.
- 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.
asset_get the master and read properties.duration before choosing times.
- Trim:
model_scenario-video-cut with startTime and endTime in seconds. Going first is what
makes every later step cheaper.
- 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.
- Grade:
model_schema_get, then the LUT twin with lutIntensity near 0.6.
- 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.
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.
1---2name: scenario-video-editing3description: "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."4license: MIT5metadata:6 source: https://skillmd.com/skills/scenario-labs/scenario-video-editing7---89# Scenario Video Editing1011## Overview1213Every image post-processing effect has a video twin, and each is a `model_run` on a tool model: one14clip in, a few numbers, one clip out. Generating or restyling footage, lipsync, dubbing and15upscaling are `scenario-video`; concatenating, compositing and captioning a cut are16`scenario-video-assembly`; the still-image side is `scenario-image-editing`. Connection and the core17loop: `scenario`. If a sibling skill named here is missing from your available skills, load it with18`skill_get` (Scenario MCP) or ask the user to install it19(https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag20the gap.2122## The twin rule2324A video effect's id is the image id with `-video` appended, its file field is `video` rather than25`image`, and the knobs are identical: `model_scenario-postprocessing-lut-video` takes the same26`lutStyle` enum and `lutIntensity` as `model_scenario-postprocessing-lut`. All eighteen have twins,27from blur and color correction through oilify, posterize and vignette.2829One twin differs: Dissolve (Video) blends the clip with a still `dissolveImage`, not a second clip;30crossfading two clips is a concat transition.3132## Quick reference3334| Need | Model or query |35| --------------------- | ------------------------------------------------------------------------ |36| Grade or stylize | `filters={"tags": ["Post Processing"]}`, plus the effect name as `query` |37| Trim to a range | `model_scenario-video-cut` (`startTime`, `endTime`) |38| Cut into segments | `model_scenario-video-split` (`cutPoints`; N points give N+1 clips) |39| Rescale or re-encode | `model_scenario-resize-video` |40| Play a clip backwards | `model_reverse-video` |41| Frames out, frames in | `model_scenario-video-to-image-seq`, `model_scenario-image-seq-to-video` |42| Subjects as layers | `model_scenario-video-layers-extractor` |43| Masks, cutouts | `recommend` with the need in the user's own words |44| Key a green screen | `model_scenario-video-chroma-key` |45| Pull the audio track | `model_scenario-audio-extract` |4647Extracted frames carry no index and share one `createdAt`, so their order exists only in the job48row's `assetIds`, and that list has come back out of time order (a confirmed defect at authoring49time). The extractor takes a scalar `video`; every frame is `extractAllFrames: true`, and50`frameInterval` (default 24 at authoring time, about one frame a second on a 24 fps clip) applies51only when that flag is off. Check the row's length: exactly the clip's `nbFrames` ids with the flag52on, about `nbFrames` / `frameInterval` with it off, sampled from frame 0 (`asset_get` reports53`nbFrames` beside `frameRate`; a short row is a dropped frame, which no reordering fixes), then,54before reassembling with `model_scenario-image-seq-to-video` or handing frames on, lay the returned55ids into `model_scenario-grid-maker` in that order (a fixed first-party id: Scenario's single grid56tool; its `images` field takes an array of 1 to 100 ids and ignores a bare id while the run still57succeeds, so past 100 frames sheet in batches or raise `frameInterval`; set `columns`, default 3 and58up to 20, so a batch reads as a near-square sheet) and read the sheet with `asset_display`, not a59download (it tiles frames at source resolution, so the file can pass 100 MB), against the clip's60free `firstFrame` and `lastFrame` and its motion; a frame that breaks continuity is out of place,61and the corrected order travels as your own id list from then on. Never rebuild order from listings62or timestamps, and a preview that runs backwards on a clean sheet is the assembler's `pingpong`63flag, not the order.6465A cutout with transparency never ships as mp4: at authoring time the removal models carried alpha66only as WebM or ProRes 4444 MOV, so read the output-format enum off `model_schema_get` and agree the67container with the user before pricing the run.6869Effect lookups go through `search`, `target="models"`, `public=true`. The `model_scenario-` ids are70constants: each is Scenario's single deterministic tool for its operation, so discovery would only71re-derive it. `model_reverse-video` sits outside that set and is an authoring-time hit: re-discover72it by name (`search` `query="video reverse"`).7374## Keying a green or blue screen7576Footage shot or generated on a solid screen goes to `model_scenario-video-chroma-key`, a fixed77first-party id: Scenario's single chroma-key tool. Footage with no solid screen is a segmentation78job instead (the Masks, cutouts row).7980- Leave `keyColor` empty: the tool detects the green or blue screen from the borders of the first81 frames. Set a hex only when detection keys the wrong color.82- `outputFormat` decides the alpha: `webm` (VP9 with alpha, the default) for web and engines, `mov`83 (ProRes 4444 with alpha) for editing and compositing apps. `mp4` carries no alpha and requires84 `backgroundColor`, a solid color composited behind the subject.85- Edges take five controls, read with `model_schema_get`: a green fringe or halo on hair and edges86 wants `spillSuppression` (default 1, the maximum, at authoring time) and a positive `edgeShrink`87 of 1 to 2 pixels; holes in the subject want a lower `tolerance` (default 0.3); a hard, stepped88 edge wants `softness` or `edgeFeather`.89- The input is capped (60 seconds at authoring time, `max_duration` in the schema): trim first.90- Generating footage to key: ask the video model for a flat, evenly lit pure green background, no91 shadows on it, and a subject wearing no green. Motion blur and fine hair key worst, so judge those92 frames first.9394## Cost follows the clip, so trim first9596On the video twins the `video` input carries `cost_impact: true`, which the image versions do not:97price tracks the footage rather than the settings. Trim to the frames that ship, then grade;98`dry_run=true` prices a payload before it runs. Video tools also outlast `model_run`'s wait window,99so launch with `wait=false` and follow with `jobs_wait`, re-calling it with the returned100`pending_job_ids`. A client-side timeout on `jobs_wait` is as harmless as the server's own: re-call101it with the same ids rather than treating the job as lost.102103Checking costs nothing: `asset_get` returns `firstFrame` and `lastFrame` as their own asset ids, so104`asset_display` one to confirm a grade before chaining another billable run onto it.105106## Field names drift between neighbors107108- Video Cut and the effect twins take a scalar `video`. Resize Video takes `video` as an109 `array: true` field capped at one item, where a bare id is dropped silently; its size is `width`110 and `height` in pixels, both optional, and one alone keeps the aspect ratio.111- The output format field is `outputFormat` on cut and split, `videoOutputFormat` on resize.112- `preserveAudio` defaults to true on cut, split and resize; the effects expose no audio field and113 pass the track through.114- Enum values are copied, not retyped: one `lutStyle` string contains a space.115- `asset_download` takes no `format` for a video: it converts image formats only. A GIF from the116 sequence tool is an image asset and takes `format: "gif"`; the `png` default flattens it to one117 frame.118119## Resizing is not reframing120121No tool model repaints a video's canvas. Resize Video takes `fit`: `contain` (default) fits the clip122inside the target, `stretch` forces the size and distorts, `cover` fills the target and center-crops123the rest. `cover` is the cheap way to an exact ratio when losing the edges is acceptable, but none124of them gives a 16:9 clip a vertical frame with the whole picture kept, so that brief needs a125decision before any spend, between two routes an order of magnitude apart in price.126127- **Generative reframe** (`query="reframe"`, Luma Ray 3.2 Reframe and Wan 2.2 Reframe,128 `scenario-video` territory) outpaints past the frame and keeps the whole picture, at by far the129 highest price in such a job. Resolution ceilings bite: a schema can allow a vertical ratio and its130 top resolution tier separately yet reject the pair at run time.131- **Compositor** (Video Studio, cropping or pillarboxing onto a vertical canvas) is cheap but throws132 away width or adds bars, and its layer geometry is `scenario-video-assembly`'s contract rather133 than a one-line setting.134135`dry_run` prices a payload without validating it, so either route can bill for a run that fails136outright or returns a mis-composed frame at exactly the right dimensions.137138## Reworking a finished video139140A request to reorder, drop, or lengthen shots in a video already rendered is an edit, not a new141generation. Regenerate only the shot whose content must change.1421431. With a music bed, pull it first: `model_scenario-audio-extract` on the master, before any split144 chops it.1452. Find the shot boundaries. `asset_get` the master for `nbFrames` and `frameRate`. Extract frames146 at the shortest `frameInterval` that keeps the clip on one sheet (`nbFrames` / 100, rounded up),147 and verify their order as above (count, sheet with the ids as an `images` array, correct against148 continuity). Each cut is a jump between neighbors in the corrected order. Its time is the 0-based149 position of the new shot's first frame × `frameInterval` / `frameRate`, accurate to one stride.1503. `model_scenario-video-split` with those times as `cutPoints` (an array, sorted, in seconds; N151 points give N+1 segments) and `video` as a scalar.1524. Confirm each segment before reordering: `asset_get` its `duration` and `asset_display` its153 `firstFrame`. Never take the row's id order as the timeline order.1545. Rebuild with one `model_scenario-video-concat`, `videos` holding every kept segment in the new155 order (2 to 50 ids). Hard cuts are the default; `transitions` holds one entry per seam.156 - **Reorder or drop**: list the segments in the new order and leave out any dropped shot.157 - **Lengthen a shot**: no tool model retimes or slows a clip. Extend it from its `lastFrame` with158 a video model (the last-frame chain in `scenario-video`) and list the extension right after159 that shot.160 - **Change what a shot shows**: regenerate that shot alone in `scenario-video` and list it in the161 shot's slot.1626. Check sync on the result: concat has drifted audio against picture (see163 `scenario-video-assembly`). Lay the extracted bed back over the rebuilt cut there, trimmed to its164 new length.165166## Worked example: a graded cutdown167168Launch every `model_run` below with `wait=false` and retire it with `jobs_wait` before the next step169reads its asset.1701711. `asset_get` the master and read `properties.duration` before choosing times.1722. Trim: `model_scenario-video-cut` with `startTime` and `endTime` in seconds. Going first is what173 makes every later step cheaper.1743. Reshape: `model_scenario-resize-video`, `video` as a one-item array, `width` and `height` at the175 delivery size, `videoOutputFormat: "mp4"`. `fit` settles the shape at this step rather than176 later: `cover` lands an exact ratio once the edges are spendable, and a shape that has to keep177 the whole picture is the reframe decision above.1784. Grade: `model_schema_get`, then the LUT twin with `lutIntensity` near 0.6.1795. Texture: `model_schema_get`, then the Grain twin with `grainProfile` (a 22-value enum, default180 `kodak_portra_400` at authoring time) on that output, last, so its grain is sized for the181 delivered frame rather than resampled by a later resize.1826. `asset_display` the result's `firstFrame` to confirm the look, then `asset_download` with no183 `format`.184185## Common mistakes186187- Grading each source clip and then concatenating: grade the finished master once, or the shots188 drift apart.189- Reaching for local ffmpeg, or for an MCP tool named `video_edit`: the surface is `model_run` on190 tool models.191- Polling `job_get` in a loop instead of `jobs_wait`, whose timeout is not an error.192- Trusting a Grain profile to add grain: the 22 profiles are looks, not intensities, and some soften193 the picture instead. Compare a frame against the input.