Magnific

View saved version →

---
name: ad-campaign
description: Make static campaign creative with Magnific - key visuals, social posts, stories, banners, posters and display ads, on-brand with a brand kit, adapted to every format and safe zone, with A/B test variants and localized versions. Use it when the user wants Magnific to make any ad, campaign, key visual, social post, carousel, banner, poster, thumbnail or "make variations of this ad" request from a marketing team or agency, including when they want a layout copied from an existing ad.
---

# Campaign creative

Agencies and in-house teams need a master that is right, then many exact adaptations of it, fast and on budget.
The common failures are drifting off-brand, re-inventing the layout in every format, and burning credits on variants that test nothing.

Follow `magnific-essentials` for pricing, project folders and waiting.
Prompt craft is in [image-prompt-craft.md](../magnific-essentials/references/image-prompt-craft.md).

## 1. Brief and project

From the request, settle: product or offer, audience, single message, mandatory elements (logo, legal line, price, CTA), channels and formats, languages, client, budget.
Find or create the client's project and pass `folderReference` on every call; agencies bill and review per project.

## 2. On-brand: use the brand kit

If the client has a kit, it owns colors, type, logo and imagery.
- Find it with `brand_kit_list` (`search` by name), read it with `brand_kit_get`. Several matches: ask; never guess.
- `images_generate` with `brandKitId` always runs Magnific One. Keep the prompt short: the subject plus hard constraints ("winter blend on a cabin table, snow outside, no text"). Do not restate palette, fonts, logo or tone.
- Use `templateSlug` (from the kit's `templates`) when the user asked for that format, and `channel` (for example `instagram_post`, `instagram_story`, `linkedin_post`, `youtube_thumbnail`, `print`) when you know the destination, so the kit's channel rules apply.
- Read `brandCheck` on the finished image (via `creations_wait` or `creations_get`) before calling it on-brand.
- Kit rules the client set (bans) are applied by the server; do not fight them in the prompt.
The full brand-kit procedure, including building a kit from a website, is in `guides_get` with `brand-kit`.

No kit: write the brand cues into a reusable style line (palette in words or hex, type feel, photographic tone) and repeat it in every prompt; offer to build a kit (`brand_kit_create` + `brand_kit_scrape_url`) if the client will come back.

## 3. Formats and safe zones

| Placement | Ratio | Notes |
|---|---|---|
| Instagram and Facebook feed | 4:5 (or 1:1) | 1080 x 1350 |
| Stories, Reels, TikTok | 9:16 | keep text out of the top 14% and bottom 20% |
| LinkedIn and X posts | 1:1 or 1.91:1 (use 16:9 if 1.91 is unavailable) | |
| YouTube thumbnail | 16:9 | 1280 x 720, readable at small size |
| Web hero, display leaderboard | 16:9, 3:1, 8:1 | very wide shapes need a `customSize` model (up to 8:1, or 16:1 on Seedream 5 Pro) |
| Print | per the printer's spec | deliver `tiff16` |

Not every model offers every ratio (Magnific One, for example, has no 4:5); use the closest supported ratio and adapt with `images_expand` or `images_crop`, or set exact `width` and `height` on a `customSize` model.
To adapt a finished ad to 4:5 (or any ratio `images_expand` and `images_crop` lack), use `design_auto_resize` with that ratio in `aspectRatios`: it keeps the layout as editable layers. In a coding agent, expanding to 3:4 and cropping to 4:5 locally also works. Do not regenerate the winner for a new ratio.

## 4. Master first, then adaptations

- Generate the master in its main format and get it approved (or pick the best of a `count` set).
- Adapt the approved master instead of regenerating per format:
  - `images_expand` to a wider or taller ratio keeps the art and generates the margins;
  - `images_crop` (with `auto: true` for subject-aware crops) for tighter ratios;
  - `design_auto

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: cinematic-shots
description: Generate film-quality shots and sequences with Magnific - hero shots from an approved keyframe, b-roll and establishing shots, documentary footage, image-to-video, multi-shot scenes, extensions, blocking or 3D previs turned into final renders - choosing the right model, resolution and camera language for each shot and staying inside the budget. Use it for any request to generate, animate, extend or re-render a shot, scene, clip or sequence for a film, series, documentary, music video or brand film.
---

# Cinematic shots

A director judges a shot on three things: does it honor the approved frame, does the camera move with intent, and does it cut with its neighbours.
A producer judges it on a fourth: what it cost.
This skill gets all four right with Magnific's video tools.

Follow `magnific-essentials` for pricing, project folders, waiting and delivery.
Read [video-prompt-craft.md](../magnific-essentials/references/video-prompt-craft.md) before writing the first prompt; it has the model limits, reference rules and camera vocabulary this skill relies on.

## 1. Start from what is approved

- Find the user's approved frames and clips in their project with `creations_search` (by `query` and `reference`, or `folderReference`) before generating anything new.
- An approved keyframe goes in `keyframes.start` as its creation identifier; that is what makes the shot match the boards.
  On Seedance 2.x and MiniMax H3 a start frame excludes visual references, so the frame itself must carry identity and set; restate them in words.
- A recurring character or location belongs in the library; see `consistent-characters`.
- Blocking, a grey-box 3D render or a rough edit can drive the final: pass it as a `video` reference and open the prompt with "the reference video fixes layout, blocking, camera path and timing; follow it exactly", then describe the final look.

## 2. Choose model and resolution per shot

| Shot | Model | Resolution |
|---|---|---|
| Hero, festival or client-final, dialogue, complex motion | `bytedance-seedance-pro-2.5` | 1080p for the final master |
| Hero shot still being explored, with someone to review takes | same model | `Draft` (about 1,000 credits for 5 s); `video_finalize_draft` renders the approved take at 1080p, at more than a direct render costs (see `magnific-essentials`) |
| B-roll, establishing, inserts on a budget | `kling-26`, `kling-30` or `kling-25`; price them, and for silent b-roll the cheapest held up as well in a live test (Kling 2.6 at about half Kling 3.0's price) | 1080p |
| Animatic, motion test, timing check | `minimax-video-3_0-max-turbo` | 480p or 768p |
| Keep real footage's motion, change the subject or look | A motion-transfer model when `video_models_list` lists one, otherwise `video_modify` | per catalog |

Read `video_models_list` before deciding: recommendations change, and private entries are not for general use.
Price with `simulate_cost` before every shot that costs more than about 500 credits, and price the whole list against any budget the user gave before generating the first clip.
A 5-second Seedance 2.5 shot is about 5,500 credits at 1080p and 2,200 at 720p; the same on Kling 3.0 is about 450.

## 3. Write the shot like a camera report

Header line: duration, aspect ratio, style as a cinematography note (lens feel, film stock or grade, era).
Then the shot: framing, ONE camera move with its start and end, ONE action with weight and contact, motivated light, the environmental force (rain, wind, smoke, moving light), and sound.
Above 8 seconds, timecode the beats (`0-3s / 3-6s / 6-8s`) and end on "settle into a clean final hold" so the editor has a usable tail.

Example for an approved keyframe of an old keeper lighting a match:

> 8 s, 16:9. Low-key storm drama, 35 mm anamorphic feel, deep shadows, warm practical light against cold blue night.
> 0-3s: slow push in from medium to medium close-up on the keeper as the match flares; rain streaks the 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: consistent-characters
description: Keep the same character, actor, mascot, product or location recognisable across many Magnific images and videos - character sheets, library assets, reference wiring per model, lookbooks, episodes and campaigns. Use it whenever a person, character, product or place must look identical in more than one output, or the user mentions consistency, continuity, the same face, the same outfit, a recurring character, a mascot, a cast, a lookbook or a series.
---

# Consistent characters, products and locations

Consistency is the most requested capability from both film studios and agencies, and the most common reason they leave a tool.
Words alone never hold a face or a product across outputs; references do.
The method: build one strong reference per recurring subject, store it, and pass it on every generation where that subject appears.

Follow `magnific-essentials` for pricing, project folders and waiting.

## 1. Check the library first

`library_list` returns the user's saved characters, products, locations and styles.
A saved asset is the best anchor there is: use it by its numeric `id`.
- In `images_generate`: `{type: "character" | "product" | "locations", identifier: "<id>"}`; the prompt may also mention it as `@<name>` where it appears.
- In `video_generate`: `{type: "character" | "product" | "style", custom_model_id: "<id>", name: "<name>"}` with no `url`. Locations are not video references; render the place as an image and pass that image.
A library id is never a creation identifier, and a creation identifier is never a library id; mixing them up fails with "creation not found".

## 2. No asset yet: build the reference

**Characters.** One character sheet image, no text, labels or annotations:

> Character reference sheet. No text, no labels, no annotations. White neutral background. Studio lighting. Consistent character appearance across all panels.
> LEFT HALF: full body front view, full body back view, face close-up.
> RIGHT HALF: [up to 5 details by priority: distinctive features, hands, signature prop, clothing details, hair, accessories].
> [Full physical description: age, build, skin tone, face shape, hair, eyes, wardrobe with colors and materials.]

Use a high-consistency model (Seedream 5 Pro, or Flux Kontext Max) at 16:9 for detailed sheets, 1:1 for simple characters.
If the user has photos or approved frames of the character, pass them as `image` references to the sheet.
When the sheet is approved, `library_create` with `type: "character"`, a name (letters, digits, `_`, `-`), a description, and 1 to 6 images (the sheet first, plus any approved stills).

**Products.** The user's real product photos are the reference; never redraw a product from words.
Several angles plus a macro of the fragile detail (cap, hinge, logo, texture) hold best.
Save with `library_create` `type: "product"` when it will recur.

**Locations.** One establishing image with no characters: "[Place]. [Time of day and light]. [Atmosphere]. Establishing shot, static camera, no characters, no text."
Reuse it as an `image` reference everywhere the scene is set; save it as `type: "locations"` for image work.

`images_variations` (modes `angles`, `expressions`, `age`, `demographics`) turns one approved image into a grid of consistent variations, each its own creation; useful for turnarounds and expression sheets.
`images_split_grid` cuts any grid image into separate creations, free.

## 3. Generate the set

- Pass the reference on EVERY output where the subject appears, not only the first.
- Keep one model and one aspect ratio across a set; a different model renders the same reference differently.
- Describe what changes (setting, pose, light, expression, action) and let the reference carry identity.
  Do not re-describe the face in new words; conflicting descriptions pull the model away from the reference.
  Do repeat wardrobe and signature props briefly, because they are what audiences track.
- Several subj

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: localize-video
description: Localize finished videos with Magnific - dub speech into other languages with lip-sync, burn subtitles, caption a video in its own language, review and correct the translated lines, and adapt on-screen text and formats per market. Use it for any translate, dub, revoice, subtitle, caption, multilingual or "make versions for Spain, Germany, Brazil..." request on a video, including ads, brand films, explainers, courses and UGC.
---

# Localize video

Localizing a master is one of the highest-leverage jobs for agencies and brands: one approved film, many markets.
The quality bar is native-sounding lines that keep brand terms right, mouths that match, and subtitles that read well, with a review step before paying.

Follow `magnific-essentials` for pricing, project folders, waiting and delivery.

## 1. What Magnific's dubbing does

One dubbing run transcribes the source, translates it, revoices it in the target language, lip-syncs the picture to the new voice, keeps the background sound, and can burn subtitles.
So a dubbed result is already lip-synced: do not add `video_speak` on top, which only spends credits and degrades sync.

- Targets: `en`, `es`, `pt`, `ar`, `ru`, `fr`, `de`, `ko`, `tr`, `it`, `id`, `ja`, `zh` (no Hindi captions).
- Up to 120 seconds per run. Longer videos: `video_cut` into parts at natural pauses (free), dub each, `video_concatenate` in order.
- Subtitles only, in the original language or another: `keepOriginalVoice: true` with `withSubtitles: true`.
- Cost (orientation): about 150 credits per second of source for the revoice, plus captions at about 4 credits per second with a 60-second minimum, doubled above 1080p and doubled again for animated caption styles. A 30-second film with subtitles is about 4,800 credits per language. Price it with `simulate_cost` for `video_dubbing`.

## 2. Pick the flow for the client

Dubbing is not on every account yet.
If your tool list has neither `video_dubbing` nor `video_dubbing_preview`, tell the user and go to section 6.

- **Chat apps with widgets (ChatGPT, Claude):** `video_dubbing` opens the dubbing studio inline; the user reviews lines, voice and captions there and confirms. Nothing is charged until they confirm.
- **Coding agents and terminals (Claude Code, Codex, Cursor):** the headless flow, one run per language:
  1. `video_dubbing_preview` with `videoUrl` (the creation identifier), `targetLanguage`, `withSubtitles`, `captionLanguage`, `subtitlePreset`. Free.
  2. Poll `video_dubbing_preview_get` with the `previewId` until `status` is `ready`.
  3. Review the preview (section 3).
  4. `video_dubbing_confirm` with the same `previewId`, `videoUrl`, `targetLanguage` and options, plus `segments` for the lines you corrected, and `folderReference`. This charges and queues the dub.
  5. `creations_wait` for the result.
Start the previews for all languages first, then review and confirm each; they run independently.

## 3. Review before paying

The preview is the only free moment to fix the dub:
- Check `sourceLanguage` is right, and `issue`: `no_speech` (nothing to dub), `same_language` (only captions will be burned), `multiple_speakers` (several voices; say so to the user).
- Read every translated `voiceText` and `captionText`:
  - brand names, product names and taglines: keep them as the client wants them (many brands keep the tagline in English; if the user did not say, keep it and state the assumption);
  - numbers, prices, units, dates and legal claims converted for the market;
  - natural register for the audience (formal "usted/Sie" versus informal "tú/du"), consistent across the film;
  - line length close to the source, so the revoiced line fits its time window.
- Pass only the changed lines in `segments` (`id` plus the corrected `voiceText` and/or `captionText`).
Show the user the corrected lines in the reply so a native speaker can approve them.

## 4. Subtitles

- `simple` and `plain` styles read as broadcast captions; a

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: magnific-essentials
description: Operating rules for every Magnific MCP job - pricing with simulate_cost, drafting cheap before expensive finals, picking models from the live catalog, uploading the user's files, saving into the right project, waiting for async results without duplicate paid calls, and delivering editor-ready files. Read it before the first Magnific generation or edit in a conversation, and whenever a Magnific job spends real money, uploads files, runs several jobs, or ends in files for Premiere, Resolve, After Effects, Photoshop or Figma.
---

# Magnific essentials

Magnific jobs spend the user's credits, run asynchronously, and end in files a professional takes into other software.
Most failures come from five habits: spending before pricing, picking a model by name recognition, sending the same paid call twice, reporting a job before it finished, and leaving results where the team cannot find them.
These rules prevent all five, and every job skill builds on them.

## 1. Know the price before you spend

- Call `account_balance` once when a job will spend more than about 1,000 credits, or when the user mentions budget or credits.
  Credits are spent through MCP even when the user's plan has Unlimited mode in the app.
- Price any call that could cost more than about 500 credits with `simulate_cost`, passing the target `tool` and the exact `arguments` you will send.
  For a batch, price one item and multiply.
- Video is where money goes. In October 2026 quotes, 5 seconds cost about 5,500 credits on Seedance 2.5 at 1080p, 2,200 at 720p, 1,000 as a Seedance Draft, 450 on Kling 3.0 and 240 on MiniMax H3 Max Turbo; an image costs 15 to 200. `simulate_cost` is the truth when they differ.
- With a budget from the user, stay inside it and report spend against it.
- Without one, choose the most cost-effective route that meets the deliverable's quality bar (720p is enough for most social video; 1080p and above is for broadcast, cinema and client masters).
  Judge the cost on that cheapest adequate route, not on a pricier route you might prefer.
  If the whole job costs under about 1,000 credits, make the deliverable and report the cost; do not stop halfway on a job the user clearly asked for.
  Above that, state the plan and its price, and wait for the user's yes before the first paid call; once they agree, run the whole plan without asking again.
  If you cannot ask (a scheduled routine, an unattended run), spend at most about 1,000 credits on the cheap stage (drafts, one test shot), show it, and quote the finals.
- Report what the job cost in the final reply.

## 2. Draft cheap, finish expensive

Professionals approve direction on cheap drafts and only then pay for the hero render.

- Make one result per deliverable unless the user asks for options, or you will actually look at several candidates before choosing; paying for takes and picking one blind wastes the rest.
  A redo after a real review is part of the job: when a result fails its check, fix it (once, with the change named) rather than shipping it.
- Images: explore with a fast model or `count` variants in one call when someone will choose among them, then finish the chosen one (a stronger model, `images_upscale`, or both).
- Video: block motion and timing on a draft model or low resolution, then render only approved shots at the final resolution.
- Seedance 2.5 offers a `Draft` resolution (about 1,000 credits for 5 seconds): `video_finalize_draft` turns that exact shot into its 1080p final (billed like a 1080p render), while a new `video_generate` would produce a different video.
  The finalize costs at least as much as a direct 1080p render and `simulate_cost` cannot quote it, so draft plus finalize always costs more than rendering the final directly.
  It pays off only when someone looks at the draft before finalizing and the shot is risky (complex motion, a face carrying the scene), or when several drafts compete and only the best is finalized; s

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: precise-image-edits
description: Edit an existing image with Magnific while keeping everything else intact - remove or replace an object, change a product, color, expression, wardrobe or text, extend the canvas, relight, fix skin, swap a background - on approved art, photos and frames. Use it for every "change only X", "remove this", "replace that", "keep everything else the same", "fix this image" or "don't regenerate it" request, and before touching any image the user calls approved or final.
---

# Precise image edits

On an approved image, the client paid for every pixel they did not ask you to change.
The most damaging habit with AI tools is "editing" by regenerating the whole image: faces shift, products move, label text breaks.
In Magnific's tests, caption-style edit prompts ruined every request they were used on.
So pick the most local tool that can do the change, and write edit prompts as instructions that lock first.

Follow `magnific-essentials` for imports, pricing, project folders and waiting.

## 1. Find the source

Locate the exact image (`creations_search` in the project, or the identifier the user gave) and edit that one.
If the user refers to "the image" after you delivered a result, they mean your latest result.
Iterations build on the last accepted version; parallel alternatives all start from the original.

## 2. Pick the most local tool

| Change | Tool | Notes |
|---|---|---|
| One object or region (replace, remove) | `images_segment` then `images_retouch` | Segment returns a mask at once (describe the thing, or give points/boxes); retouch `replace` needs a prompt for the region, `erase` removes it |
| Several separate regions | One segment + retouch per region, each on the previous result | Chain so all fixes end in one final image |
| A whole-image instruction that must keep framing (expression, wardrobe color, time of day, swap a held product) | If `images_models_list` lists `ideogram-4-5`: `images_generate` with `mode: ideogram-4-5`, `preciseEdit: true`, the source as the first `image` reference. Otherwise: `images_generate` with the model `agentRecommendation` gives for `image_edit` (in October 2026 `seedream-5-pro`, or `imagen-nano-banana-2` for a final that needs maximum fidelity), the source as the first `image` reference and its aspect ratio | `preciseEdit` edits the first reference in place and takes no `aspectRatio`; the fallback makes a new image from the reference, so check it closely (section 6) |
| Only the background | `images_replace_background` | Re-lights the subject to match; use the lock-first `images_generate` route if the subject's light must not change |
| Cut-out | `images_remove_background` | |
| More canvas, new ratio | `images_expand` | Keeps the original pixels |
| Tighter framing, exact pixels | `images_crop`, `images_resize` | Not AI |
| Sharpness, resolution | `images_upscale` | Use a precision or low-creativity setting to keep detail faithful |
| Lighting only | `images_relight` | 1 to 4 lights with direction, color and intensity |
| Skin | `images_skin_enhancer` | |
| Camera angle | `images_change_camera` | Regenerates the view; not pixel-preserving |

Outside that row, `images_generate` is the last resort for edits, used only for a whole-image creative rework.

## 3. Masks and retouch

- `images_segment` with a plain prompt ("the paper cup in her right hand", "the small sign on the back wall"); add a box or points when the image has several candidates.
- `images_retouch` with the original as `creationIdentifier` and the mask as `maskCreationIdentifier`.
  - `replace`: the prompt describes only what the masked region becomes, matched to the scene: "a matte black stainless travel tumbler held the same way, same lighting and perspective as the hand".
  - `erase`: no prompt needed; the model fills with the plausible background.
- Pick a model from `retouch_models_list` when the user cares about the look, or leave Auto.
- Mask slightly larger than the object for re

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: previs-storyboard
description: Turn a script, scene, treatment or idea into a shot list, storyboard frames and a timed animatic with Magnific - consistent characters and locations, one visual style across frames, cheap draft motion for timing, and a board the team can review. Use it for previs, pre-vis, storyboards, shot lists, animatics, lookbooks of a scene, pitch boards and "visualize this script" requests from filmmakers, agencies and studios.
---

# Previs and storyboards

Previs exists to make decisions cheaply: framing, coverage, pacing and continuity, before anyone pays for final shots.
So the craft here is clarity and consistency at low cost, not polish.
The output is a shot list the crew can read, frames that look like one film, and an animatic that plays at the right length.

Follow `magnific-essentials` for pricing, project folders and waiting.

## 1. Shot list first, in text

Break the scene into beats (setup, turn, payoff), then shots.
One numbered table: `# | dur | size and angle | camera move | action | dialogue or sound | notes`.
- Sizes: EWS, WS, MS, MCU, CU, ECU, insert, OTS, POV.
- Moves: locked, push in, pull back, pan, tilt, track, crane, handheld, orbit (with an arc).
- Keep screen direction and eyelines consistent; flag any line cross.
- Durations should add up to the scene's page time (about one minute per script page).
Show the table before generating anything; it is the contract for everything after it. Save it in the project too (an uploaded text or image sheet), so the crew finds it next to the boards.

## 2. Cast and sets before frames

Consistency across frames comes from references, not from repeating adjectives.
- Look for existing characters, products and locations with `library_list`. Use a library asset by its numeric `id`: `{type: "character" | "product" | "locations", identifier: "<id>"}` in `images_generate`.
- A character without a library entry gets a character sheet first (see `consistent-characters`), then `library_create` if it will recur.
- A recurring location gets one establishing frame with no characters ("[Location]. [Time of day and light]. [Mood]. Establishing shot, static camera, no characters, no text."), reused as an `image` reference for every frame set there.

## 3. Frames: one model, one ratio, one style

- Pick one image model and keep it for the whole board; switching models mid-board breaks the look.
  For clean boards, a fast reference-capable model is enough (check `images_models_list`; Seedream 5 Pro is the general default, Nano Banana 2 Lite is the cheapest draft option).
- One aspect ratio for the board: the delivery ratio (16:9 or 21:9 for cinema, 9:16 for vertical).
- Write a style line once and paste it into every frame prompt: "Storyboard frame, painterly digital sketch, muted palette, clear silhouettes, cinematic lighting, no text, no panel borders."
- Each frame prompt: shot size and angle, who is where, the action at that instant, light. Pass the character and location references on every frame where they appear.
- Generate frames for different shots in parallel calls, then wait on all of them together.
- Cheaper rough option: one image laid out as a 2x2 or 3x3 storyboard grid, then `images_split_grid` to cut it into frames (free). The style is very consistent; the resolution per frame is lower.
- `images_variations` with `variationMode: "storyboard"` turns one frame into a grid of related shots; useful for coverage ideas.

## 4. Animatic: cheap motion, right timing

In a coding agent the cheapest useful animatic is the boards themselves, timed to the shot list with simple push and pan moves, a burned-in timecode and temp sound, built locally with ffmpeg and uploaded: it costs nothing and is what an editor needs to check timing.
Animate on a draft model only the shots whose camera or character motion must be seen, as below.

- Animate each frame as its own short clip with the frame as `keyframes.start`, on a draft model at low resolution: MiniMax

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: product-imagery
description: Make product images with Magnific that keep the real product exact - e-commerce packshots on pure white to marketplace specs (Amazon, Shopify, Zalando), cut-outs, lifestyle and in-situ scenes, new angles and colorways, packaging and label mockups, and whole catalog sets. Use it whenever the user has a product (photo, packshot, SKU, bottle, shoe, box, garment, device) and wants Magnific to make images of it, even if they only say "put my product in a nicer scene" or "make listing photos".
---

# Product imagery

Product work is judged on one thing before anything else: is it the real product?
A changed logo, an invented label line or a different cap costs the client a rejected listing or a recall of the ad.
So route each job by how much the product's pixels must survive, and say plainly when a step is generative.

Follow `magnific-essentials` for uploads, pricing, project folders and waiting.
Prompt craft, including lock-list edit prompts, is in [image-prompt-craft.md](../magnific-essentials/references/image-prompt-craft.md).

## 1. Get the product in

- Import every product photo once (`creations_upload_image` for a URL, `creations_request_upload` then PUT then `creations_finalize_upload` for local files, `creations_upload_file` for a chat attachment), with the real file names, into the client's project.
- A saved library product (`library_list`) is used by its numeric id as `{type: "product", identifier: "<id>"}`.
- Ask for, or note the absence of, the angles you need. A real photo of an angle always beats a generated one.

## 2. Route by fidelity

| Deliverable | Route | Product pixels |
|---|---|---|
| Marketplace main image on pure white | Cut out with `images_remove_background`, then put it on white (see 3) | Kept |
| Same photo, new backdrop | `images_replace_background` (re-lights the subject to match) | Kept, relit |
| Bigger or sharper | `images_upscale` (precision or low-creativity settings), then `images_resize` to exact pixels | Kept |
| Wider canvas for a banner | `images_expand` to the target ratio | Kept |
| An angle you have no photo of | `images_generate` with every real view as a reference and a product lock, or `images_change_camera`; compare small details (stitching, logos, trims) with the photos and keep the faithful one | Generated; flag it |
| Product in a new scene (lifestyle, in-situ, ad) | `images_generate` with the product as the first reference and a product lock | Generated; check it |
| New label or artwork on the same pack | `images_generate` with structure and artwork references | Generated |
| Same product, new colorway | The whole-image edit route of `precise-image-edits` (`preciseEdit` on `ideogram-4-5` when the account lists it), the product as the first `image` reference | Edited in place with `preciseEdit`; otherwise generated, so compare the label and shape |

Never use `images_generate` to "clean up" a product photo that only needs a cut-out, a backdrop or upscaling; it regenerates every pixel, including the label.

## 3. Marketplace packshots

Common specs (confirm the client's channel):
- Amazon main image: pure white background (RGB 255,255,255), product fills about 85% of the frame, no text, props or watermarks, at least 1000 px on the long side; 2000 x 2000 is the safe square.
- Shopify and most storefronts: square 2048 x 2048, consistent padding across the catalog.
- Fashion marketplaces: often 3:4 or 2:3 on light grey; check the brief.

Plan the whole chain before the first paid call, and pay only for steps whose output the next step uses; an upscale or cut-out you abandon is wasted money.
When the user says the product must not change, the route is cut-out plus white only: no relight, no regeneration.

In a coding agent (Claude Code, Codex, Cursor, Gemini CLI), use the bundled [scripts/packshot.py](scripts/packshot.py) (Pillow only) for every measurement and framing step, and report the numbers it prints, never an estimate.
Run it by its ful

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: sound-and-voice
description: Create and finish sound with Magnific - voiceovers and narration, character dialogue, lip-sync to an existing shot or a still, music beds and jingles at a given BPM and length, sound effects and ambiences, scoring a cut, voice changing, cleaning a recording, mixing tracks and delivering WAV stems. Use it whenever the user wants Magnific to make or change a voice, VO, narration, dialogue, lip-sync, talking head, music, soundtrack, jingle, SFX, Foley, ambience or audio mix, alone or for a video.
---

# Sound and voice

Sound sells the picture, and it is where AI assistants under-deliver: random voices, music that ignores the cut, and everything baked into one track the editor cannot mix.
Professionals want a directed performance, music that fits the length and tempo, and separate stems.

Follow `magnific-essentials` for pricing, project folders, waiting and delivery.

## 1. Pick the path for speech

| Situation | Path |
|---|---|
| New video where people speak | A native-audio video model; lines in quotes after the speaker (see `cinematic-shots`) |
| Voiceover or narration over picture | `audio_tts`, then `video_audio_mix` |
| An existing shot that needs a line lip-synced | `audio_tts` (or the user's recording), then `video_speak` with `videoUrl` and `audioUrl` |
| A still portrait that should talk | `audio_tts`, then `video_speak` with `imageUrl` and `audioUrl` (talking head) |
| One voice that must stay identical across several clips | `audio_tts` with one `voiceId` per character, then `video_speak` per clip |
| Keep a recorded performance, change the voice | `audio_voice_change` |
| Translate and revoice a finished video | the `localize-video` skill (dubbing already includes lip-sync) |

`video_speak` is for an exact voice or a supplied track; read `video_speak_models_list` for which models take an image or a video and their audio limits.
Before lip-syncing to an existing shot, make the dialogue track exactly the shot's length (pad with silence before and after the line, where it should start and end; trim if it runs long), so the synced shot keeps every frame and the stem drops into the timeline in sync. In a coding agent that is one ffmpeg command; otherwise generate the line shorter than the shot and say where it starts.

## 2. Voice: cast, direct, then generate

1. **Cast.** `audio_voices_list` with a `search` built from the brief (age, gender, accent, texture, use: "old male gravelly", "warm female narrator british", "young energetic spanish"). Choose from what returns and say why; never take the first voice blindly. Cloned voices are `source: mine`. In chat apps with widgets, `audio_voices_show` lets the user pick.
2. **Read the notation.** Call `audio_tts_direction` with the model you will use before writing `text`; each model reads cues differently:
   - `eleven_v4` (default): inline tags that describe something heard, which can be chained: `[tired, low voice] The light has never gone out... [pause 1s] Not once in forty years.`
   - `eleven_v3`: one short tag per phrase.
   - `eleven_turbo_v2_5`: only `(pause 1s)` works; any other bracket is read aloud.
   - Gemini TTS: put the overall performance note in `systemInstruction`, short cues inline.
   - `seed_audio_1_0`: a scene script with speakers described in prose; only quoted text is spoken; no `voiceId`; `maxDuration` required.
3. **Write to time.** About 2.5 words per second for VO, closer to 2 for a slow, tired or whispered read, and every pause tag adds its length; leave air for the picture. Ellipses add weight; capitals add emphasis.
   When the line must fit a shot, count it before generating and trim the words or the pauses until it fits, so the first take lands; if a take still overruns, shorten the text rather than paying for takes until one fits.
4. **Generate.** `audio_tts` with `text`, `voiceId` (an integer), and `model` if not the default. Two-person dialogue: `speakers` with exactly two voices from the same provide

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: video-ad
description: Produce short video ads with Magnific - product commercials, social spots for Reels, TikTok and Shorts, UGC-style talking videos, and TV-style 15/30-second cuts - from a brief, a packshot or a key visual, with the product kept exact, music or voiceover, and every format the media plan needs. Use it whenever someone wants an ad, spot, commercial, promo, product video, UGC video or social video made with Magnific, even if they only say "animate this product" or "make a reel".
---

# Video ads

Video ads are one of the most common jobs people bring to Magnific through AI assistants.
The professional bar is simple to state and easy to miss: the real product stays exact in every frame, the cut lands on time with sound, and the client sees the cost before the expensive renders.

Follow `magnific-essentials` for pricing, uploads, project folders, waiting and delivery.
The video prompt craft is in [video-prompt-craft.md](../magnific-essentials/references/video-prompt-craft.md); read it before writing the first `video_generate` prompt.

## 1. Lock the brief in one pass

Settle these from the request, and state the ones you had to assume:

- Platform and format: Reels, TikTok, Shorts and Stories are 9:16; YouTube and web are 16:9; feed is 1:1. No video model renders 4:5; make 1:1 or 9:16 and reframe later if needed.
- Length and shot count: 6, 10, 15 or 30 seconds; roughly one shot per 3 to 5 seconds.
- Product source: a packshot creation, a saved library product (`library_list`), or the user's file to upload.
- Sound: music, voiceover, on-camera dialogue, sound effects, or silence.
- Budget, and the project to save into.
- The end card: where the logo and the call to action go. Leave clean negative space for them; let the editor add exact type and logos, because generated text and logos are unreliable.
  In 9:16 for Reels, TikTok and Shorts, put that space in the upper or middle third: the platform's captions and buttons cover the bottom fifth of the frame.

## 2. Write a shot plan before you spend

A numbered table: shot, seconds, framing and camera move, action, product moment, sound.
Make the first 1 to 2 seconds a hook (motion, reveal or a question), the middle the proof (product in use, texture, benefit), and the last shot the payoff on the product with space for the end card.
A 15-second three-shot luxury spot, for example: macro texture reveal 0-5 s, product in hand or in use 5-10 s, hero product on a surface with slow push-in and negative space 10-15 s.

## 3. Keep the product exact

The product drifting (wrong cap, invented label text, changed proportions) is the failure clients reject first.
Pick one of these wirings per shot:

- **Start frame route (most control):** generate a still for each shot with `images_generate`, passing the packshot as the first `image` reference (or the library product as `{type: "product", identifier: <id>}`), with a lock-list prompt ("the exact product from the reference, same shape, cap, label and colors"). Approve the stills, then animate each with `keyframes.start`.
- **Reference route (fewer steps):** `video_generate` text-to-video with the product in `references[]`: a creation as `{type: "image", url: <identifier>}`, or a library product as `{type: "product", custom_model_id: "<id>", name: "<name>"}`.

Seedance 2.x and MiniMax H3 cannot take a start frame and visual references in the same call, so never send both there.
Inside any move that turns the product, add a guard: "during the move the label, cap and proportions stay exactly as in the product reference."

## 4. Draft, then render the finals

- Price the plan with `simulate_cost` (one shot, times the number of shots) and compare it with the budget before anything else.
- Draft motion and timing cheaply first when the brief is new: MiniMax H3 Max Turbo or Seedance 2.0 Fast at 480p or 720p, or Kling 2.5. Show the drafts; when nobody can review them, check them yourself (`video_extract_frames` is free) for p

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: video-finishing
description: Finish and deliver video with Magnific - upscale to 2K or 4K, SDR to HDR, LUT and manual color grades, matching a look, relighting, cleaning up or changing existing footage (remove text, logos and objects, swap elements, restyle), reframing for other aspect ratios, retiming, extending, joining, cutting out the subject, and rendering ProRes, DNxHR or PNG sequences for the edit. Use it for any request to improve, fix, grade, upscale, reformat, clean up or deliver a clip that already exists.
---

# Video finishing

Finishing is where generated footage becomes a deliverable.
Professionals expect three things: changes to existing footage keep everything they did not ask to change, steps run in an order that protects quality, and the master arrives in their pipeline's format.
Finishing tools also bill per second of footage, so a duplicate call is expensive: one 4K upscale can cost several thousand credits.

Follow `magnific-essentials` for pricing, project folders, waiting and delivery formats.

## 1. Read the source first

Find the clip (`creations_search` in the project) and read `video_metadata` (duration, resolution, fps, audio) before choosing anything.
Several tools cap input at 20 seconds and 200 MB (`video_color_grade`, `video_color_transfer`, `video_vfx`, `video_motion_shake`, `video_remove_background`); `video_relight` processes at most 240 frames.
For a longer clip, cut it into parts with `video_cut` (free), finish each, and join them with `video_concatenate`.

## 2. Order of operations

1. Fix and change content: `video_modify` (clean-ups, swaps, restyles), `video_relight`, `video_remove_background`.
2. Edit: `video_cut`, `video_speed`, `video_extend`, `video_concatenate`, `video_magic_cut`.
3. Reframe: `video_crop` to other aspect ratios, or the fallback in section 6.
4. Grade: `video_color_grade` or `video_color_transfer`.
5. Upscale: `video_upscale` (resolution, fps, detail).
6. HDR: `video_hdr`, only when an HDR master is asked for.
7. Deliver: `creations_deliver`.

Why this order: generative steps (modify, relight, reframe) regenerate pixels, so anything done before them is lost; grading at the source resolution is cheaper and stays inside the 20 s / 200 MB caps; upscaling last means the final pixels carry the final grade.
Say so if you change the order for a reason.

## 3. Upscale

- Read `video_upscale_models_list` first: it lists the modes (`topaz`, `magnific`, `magnific_precision`), required parameters and ranges.
- Topaz: faithful resolution and fps work; set `targetResolution` as a pixel width (3840 for UHD 4K) or `upscaleFactor`, and an `enhancementModel`; frame interpolation for fps changes.
- Magnific modes: generative detail (`magnificResolution` up to `4k`); precision mode stays closer to the source, which suits locked, approved shots.
- Price it with `simulate_cost` (it bills per second), and call it once. If the call is slow to return, wait on the creation; never re-send it.

## 4. Color

- `video_luts_list` gives catalog LUT ids; `video_color_grade` applies one (`lutId`, `intensity` 0-100) and/or manual `adjustments` (exposure, contrast, saturation, temperature, tint, hue).
  Teal and orange, bleach bypass, warm film and similar looks map to catalog LUTs; soften with `intensity` around 60 to 85 and trim with adjustments.
  A LUT named for one half of a look may need the other half added: for teal and orange, warm the skin and highlights with a small positive `temperature` if the LUT only pushes teal.
  Check one graded frame (`video_extract_frames`, free) before paying for the upscale, and judge it against the look, never against the LUT's name: teal and orange means shadows and sky toward teal, skin, highlights and warm surfaces toward orange, with visible separation between them. A frame that shows only a contrast or saturation lift is not the look yet.
  Compare candidate LUTs on the same frame side by side, pick by what the frame shows, trim with `temperature`

Preview of the first 4,000 characters. Read full instructions →