Scenario Image Editing

Overview

Editing an existing image is a model_run on a tool model: one file in, a few numeric knobs, one or more assets out, nothing to prompt on most of them. Generating a new image, prompt-driven edits and masked inpainting are scenario-image; the same effects on footage are scenario-video-editing; stacking layers is scenario-video-assembly (Image Studio). Connection and the core loop: scenario. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

Quick reference

Two discovery lanes. A family is browsed with search (target="models", public=true) by tag. A single utility is a capability, so it goes to recommend with capability="img2img" and the need in the user's own words, which names the purpose-built tool and prices it against the general editors; when it answers a utility job with general editors only, find the tool by name with search and filters={"tags": ["tool"]}, as the watermark row does:

Need	Route
The effects family	search, filters={"tags": ["Post Processing"]} (40 hits, image and video)
Upscale or enhance	search, filters={"tags": ["image-upscale"]}
Cutouts, relight, layers, vector	recommend: at authoring time each lane returned its purpose-built tool ranked by measured cost and latency against the general editors, where search returned the same tools with nothing to rank them by
Watermarks, burned-in text	search, query="text remover", a name lookup: at authoring time recommend sent watermark removal to general instruction editors and missed the purpose-built Photoroom Text Remover
Tiles, sheets	none: model_scenario-image-slicer, model_scenario-grid-maker (fixed first-party ids, each Scenario's single deterministic tool for its job)

Reframe ids below are authoring-time hits: re-discover them.

The effects family

Eighteen effects share one shape, a required image file plus one to three knobs: blur, chromatic aberration, color correction, crystallize, cubism, desaturate, dissolve, dodge and burn, glow and bloom, grain, 3D color LUT, oilify, parabolize, posterize, sharpen, solarize, tint, vignette.

Ranges are per tool and unguessable. posterizeThreshold runs 0 to 1 (default 0.5) while Color Correction's temperature, contrast and saturation run -100 to 100 with gamma on 0.2 to 2.2, all from model_schema_get. Not every knob is a number: Grain takes a 22-value profile enum, a color temperature and a boolean, no strength control at all. Those profiles are looks, not intensities, and some soften instead of texturing: compare against the input rather than assuming grain landed. Grain's grainColorTemp (2000 to 10000) hides a sharper trap: the 6500 default is not neutral, and it warms the frame and lifts blacks harder than a restrained LUT pass does, so the texture step quietly re-grades what the grade step just set. Set it deliberately and judge the result against the graded input, not the original; which direction neutralizes it is unverified, so compare one frame each side of 6500 before a batch. Defaults disagree too: Color Correction's are no-ops (nothing set returns the input unchanged and still charges) where LUT and Posterize ship a visible default.

lutStyle holds 140+ exact strings, one of which contains a space (cgc_look_teal and orange), so copy them from the schema rather than retyping. Prefixes group them: cgc_film_emulation_* and rec709_* emulate film stocks, cgc_log_to_rec709_* expects log footage and will over-contrast an ordinary render, and the bulk of the list (cgc_look_*, pond5_*, distant_land_*, shutterstock_*) are look packs. Five bare presets sit outside every prefix, and one of them, teal_orange, is the model's default: leave lutStyle unset and the grade that lands is teal and orange, not neutral.

These finish inside model_run, returning status: "success" with the assets attached, so no jobs_wait. They are flat-priced: at authoring time every effect dry-ran at 1 CU whatever the input size (Resize Image at 2), so one dry_run stands for the family, where an upscale's price moves with output pixels. Chain them by passing one run's asset_id to the next. The pipeline order across this skill: reshape and upscale first (see the next section), then grade, then texture. Grain and sharpening are high-frequency effects that any later resize interpolates away, so they go last, at delivery resolution; a LUT is resolution-tolerant and sits on either side.

Upscaling is a model family, not a knob

Upscalers are img2img models, many taking no prompt at all: discover with filters={"tags": ["image-upscale"]} (13 hits at authoring time). Fidelity upscalers (Topaz, Recraft Crisp) sharpen and enlarge what exists, the pick when output must stay on-model; creative ones (Magnific Creative, the Clarity pair) carry a creativity dial that invents detail and can redraw fine features, so compare against the source. Sizing comes only from model_schema_get and varies per model: a factor, a target resolution or megapixels, or just image with no dial (2x to 16x and 4K to 8K ceilings were typical, not bounds). Cost follows output pixels: dry_run=true, top-level on model_run and never inside parameters, prices the exact size before a batch. An upscale can also outrun model_run's wait budget where the effects above never do: a modest one still returns status: "success" inline, a larger one returns status: "in_progress" and a job id for jobs_wait, re-called with any returned pending_job_ids as job_ids. Purpose-built variants protect seams on tileable textures and continuity on 360 panoramas: see scenario-textures and scenario-skyboxes.

Expanding a canvas is four different tools

• Reframe (model_scenario-gemini-reframe): an aspectRatio enum plus a resolution tier (1K, 2K, 4K), so exact pixels are out of reach; optional prompt. The enum is approximate: 4:5 came back 1856x2304 (29:36), so a true ratio needs a Resize Image pass after it (fit: "cover", so it crops the sliver instead of squashing).
• Smart Reframe (model_scenario-smart-reframe): width and height are required and exact, and it protects on-image text, brand marks and palette. textDensity: "DENSE" costs substantially more.
• Photoroom Expand: exact outputWidth and outputHeight up to 4096, plus a seed.
• Photoroom Uncrop: rebuilds a subject the frame edge cut off.

Resize Image (model_scenario-resize-image, a fixed first-party id: Scenario's single exact-dimension resize tool, so discovery would only re-derive it) is none of these: it scales pixels to width and height (one alone keeps the ratio) and never invents canvas; fit decides what an off-ratio box does (contain, the default, may land smaller than the box, stretch distorts, cover center-crops to exact dimensions).

Both reframes recompose generatively rather than filling canvas, and at tens of times an effect's price they are the chain's expensive step: dry_run them. They re-render, so reframe first and grade after: a grade or grain pass beforehand comes back partly reinterpreted.

Cardinality

Effects take a scalar image. Resize Image (images, max 10) and Grid Maker (images, max 100) are array: true, where a bare id is silently dropped and the run succeeds having ignored it.

Worked example: grade a key art, then export at size

1. upload_asset the file, then upload_asset_complete unless it went inline under ~100KB.
2. Reshape first: Resize Image to the delivery size, with images as an array even for the one file.
3. model_schema_get on model_scenario-postprocessing-lut (a fixed first-party id: Scenario's single deterministic LUT tool, so discovery would only re-derive it), pick a lutStyle from its enum, price it with model_run and dry_run=true, then run it with lutIntensity near 0.6 for a restrained grade.
4. Grain last, on that output, so its texture is sized for the shipping frame.
5. asset_display to review, asset_download to save.

Common mistakes

• Reaching for an image_edit MCP tool, or for local ImageMagick or Pillow: the surface is model_run on tool models.
• Prompting an effect ("more posterized"): they read numbers only. Reframe and the layer extractors take text.
• Slicing or extracting layers before grading: both return one asset per piece, so every piece then needs its own run.
• Saving a traced SVG with asset_download: it comes back rasterized, so take the stored file from asset_get's url with curl -L.