scenario-image-editing — Claude Code skill: setup and features

---
name: scenario-image-editing
description: "Use when editing an existing image on Scenario through MCP with a tool model, not a new generation: upscale or enhance to 2x, 4K, 8K, super resolution, 3D LUT color grade, color correction, posterize, solarize, vignette, film grain, blur, sharpen, glow, chromatic aberration, oilify, cubism, crystallize, dodge and burn, tint, desaturate, expand or uncrop, reframe an aspect ratio, resize to exact pixels, slice tiles, contact sheet, split into layers, remove a background or watermark, vectorize."
license: MIT
---

# 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`.