---
name: upscale
description: Route every upscale — close-up, full figure, character sheet, film still, start frame, a cheap re-draw, skin, a finished video, video takes — to the right Magnific or Topaz setting, scale chosen by the input size and the price quoted first.
---
# Image and video upscaling

FlashBoards user skill, version 1.2.3 (2026-10-13).

On the board, read these guides with `list_skills` and `get_skill` when the assistant exposes them; otherwise use the hosted index through an available read-only retrieval tool. Use that runtime’s actual model discovery, current page context and guarded board actions for execution. Keep native readiness, approval and cost gates; do not claim a guide was read when retrieval is unavailable.

Read related guides with `get_skill({skillId:"<id>"})` or the [hosted index](https://pub-78da82d51ed14147ac554d38094b0c0b.r2.dev/user-skills/1.2.3/index.html). Reading a guide does not start or authorize a paid generation.

Work for the person's own images and videos.

## Entry level — the quick route first

Make everything first on the cheap route (pictures on GPT Image 2.5 Flare 2K (`gpt-image-25-flare`) at `quality: "low"`, video on H3 Max Turbo (`minimax-h3-max-turbo`) 480P). Upscale only the pick the person likes: Magnific for pictures, a Seedance 2.5 re-shoot or Topaz Starlight for video. With two or more results, ask which ones before the upscale.

## How to run it

- Pictures: `list_media_enhancement_models` → `estimate_media_enhancement_cost` → `enhance_media` with the same input → `get_media_enhancement`. The source is the person's own image as `source: {generationId}` (a result of this account, read on the server — also a crop or pad result) or an upload as `source: {imageReceipt}` from `show_media_upload_picker`; a public HTTPS image goes in `sourceUrl`. Pass the same source to the quote and the run. The result is an image `generationId`.
- Video: `estimate_video_enhancement` → `enhance_video` with `source: {generationId}` or `{videoFinishingTaskId}` (the person's own video, read on the server) → `get_generation` with the returned video `generationId`.
- **"Ultra Sublime" is a setting, not a model**: `modelId: "magnific-precision-v2"` with `flavor: "sublime"` and `ultraDetail: 100`, at the scale below.

## 1 · Classify the job

| Input | Go to |
|---|---|
| A face close-up or portrait | `upscale-closeup` |
| A full figure, a wide shot, small faces | `upscale-fullbody` |
| A character sheet (close-up + full body in one image) | `upscale-sheet` |
| A film still, a screenshot, a small reference | `upscale-film-still` |
| A frame that will start a video | `upscale-start-frame` |
| "Just make it bigger, fast and cheap" — pixel-exact fidelity not needed | `upscale-regenerate` |
| Only the skin of a big face | `skin-enhance` |
| A finished, edited video | `upscale-video-final` |
| Video takes in progress | `upscale-video-takes` (do not upscale takes) |

## 2 · Pick the tier

Ask or infer one priority: fast, cheap or best. If the person says nothing: best for single images, cheap for batches.

## 3 · The pipeline

```
generate the frame at the right size ─── upscale-start-frame
        ▼
upscale the still ── upscale-closeup / upscale-fullbody / upscale-sheet / upscale-film-still
        ▼ (big face only, optional)
skin ────────────── skin-enhance
        ▼
video takes ─────── upscale-video-takes   (generate at the final resolution)
        ▼
edit, then ONE final pass ── upscale-video-final
```

## 4 · Rules (break none)

1. **Pick the scale by the input size**:
   - about 1200 px and more (a sheet, a big frame) → Precision V2 sublime **2×** with `sharpen: 5`, `smartGrain: 12` (a grainy analog look) — 4× of the same image downgrades the look;
   - a small standalone 1K image, about 700 px (one close-up, one full figure) → Precision V2 sublime **4×** — the sharpest face;
   - a character sheet → upscale the close-up and the full figure as **separate images** (`upscale-sheet`).
2. **Same settings, another run = the same face, different fine texture.** For the best still run 2–3 times and pick; every run is charged.
3. **Blurring the input first does not help**: the upscale keeps the blur.
4. **Fix the character before upscaling**: the upscale is faithful to mistakes too.
5. **Skin enhancement only on big faces**: on a full figure every version ruined the face.
6. **GPT Image 2.5 at 4K paints on close-ups** (brush-stroke brows): close-ups at 2K, 4K only for wide shots.
7. **A plain resize adds pixels, not detail.**
8. **High creativity on the Creative upscaler changes the person** — never on a character.
9. **Upscale the final cut, not the takes** — video enhancement is the most expensive step.
10. **Quote before every launch**: the price grows in steps with the output size. **Never upscale an upscale**: a bigger scale is made from the source.

## Execute through MCP or on the board

Use the person's FlashBoards account; never ask for a personal provider key or run the source's local scripts. Discover `get_account`, `list_generation_models` and the tools of this client first: a published guide does not prove a feature is deployed.

**Headless, no open board.** Quote with `estimate_generation_cost` (skill models: `estimate_skill_model`), then run `generate_image`, `generate_video`, `generate_audio` or `run_skill_model` with one stable `generationAttemptId` per logical attempt. Pass `maxCostUsd` only when the current operation and selected model support it; otherwise use the quoted cost and the person's explicit approval with the supported controls. Never silently ignore an unsupported spending cap; make one `get_generation` check after `retryAfterSeconds`. Pass the person's own results by `generationId`: images in `referenceGenerationIds`, `firstFrameUrl` and `endFrameUrl`, audio in `referenceAudioUrls` or `targetAudioUrl`, videos in `referenceVideoGenerationIds`. They are read on the server; signed result links do not work as public URLs. Every `generationId` a tool returns stays valid: a later read of the same result gives a different string, and both work. Film frames and gallery pictures go in by `previewHandle`: `referencePreviewHandles` of the generation tools, a `{previewHandle}` source of `arrange_images`, `crop_image` and `pad_image`, and `describe_media`. New files come from `show_media_upload_picker` as receipts. The person's character comes in as its sheet, by `generationId` or as an upload; there is no search by name. If the person names a character without the sheet, ask for it or make one with `character-sheet`; do not scan recent results for it. Free server steps: `trim_video`, `concat_videos`, `conform_video`, `replace_video_audio`, `extract_video_frame`, `extract_video_audio`, `detect_video_cuts`, `crop_image`, `pad_image`, `arrange_images`, `cut_audio_span`, `concat_audio_tracks`, `mix_audio_tracks`, `fit_audio_duration`, `add_audio_reverb`. Check every result with `describe_media` (a question about an image; `model`, `mode` and `sourceRange` only for a video) and `transcribe_media` for speech. Both checks are paid: `describe_media` costs a fraction of a cent for an image and about 2–4 ¢ for a short video (more for a long one), `transcribe_media` under 1 ¢ a minute — count the checks you plan in the price you name before the first paid step. `describe_media` is not reliable about sound: it misses effects mixed under music and can hear voices or instruments that are not there. Check speech with `transcribe_media` and ask the person to listen for effects and music. Never repay an uncertain submission; reuse an attempt ID only for the identical request. Make each new `requestId` or `generationAttemptId` unique, for example the task, the date and a short random suffix: an ID used before, even in another chat, replays that earlier request or answers `REQUEST_ID_CONFLICT`.

**On the board.** Inspect with `list_board_sessions` and `get_board_snapshot` and carry the same `sessionId` and a fresh `activeBoardId` as `expectedBoardId`. Native cards: `execute_board_action` (`listNativeModels`, `setModel`), `prepare_board_generation` with ordered board items or owned outputs, then one `generate_on_board` within the authorized budget. Board media tools: `list_media_tools` → `start_media_tool` → `get_media_tool_run`. Put headless results on a board with `add_media_to_board`.

Keep mandatory safety settings and the live limits of each model. Prices, timings, endpoints and "free retry" claims in the sources are historical, not FlashBoards contracts. If a step this guide needs is not available or is refused (a tool error, `audio_not_configured`, a missing model or input), keep the finished assets, tell the person which step is blocked and why, and ask how to go on. A single generation that ends `failed` is not a blocked step: submit it once more with a new `generationAttemptId` (reworded if it may have hit the content checker), and stop to ask only if it fails again. A failed attempt is not always refunded, so the retry may be paid again and `maxCostUsd` caps each request on its own: count both against the budget the person approved. Never swap in another route on your own: no image model redrawing a layout or a frame, no `describe_media` in place of the frames it should check, no clip generated only to take its sound, no picture drawn where the guide takes a film frame.

## Source and related guides

- [Original Learn guide](https://flashboards-h01.vercel.app/learn/post-production/ai-upscaling/skills/upscale.md)
- Updated from the owner's skill sources of 2026-10-11.

Read: `upscale-closeup`, `upscale-fullbody`, `upscale-sheet`, `upscale-film-still`, `upscale-start-frame`, `upscale-regenerate`, `skin-enhance`, `upscale-video-final`, `upscale-video-takes`. Source experiments and demo materials are historical; use the person's own approved media.