Voyager Video & 3D

View saved version →

---
name: voyager-cloud
description: "Cloud: Voyager account, credits, estimates, references, jobs, results, brand kits and Cast for hosted generation. Read first for any Voyager image, video, audio or 3D request in ChatGPT or Codex."
---

# Voyager in the cloud

This plugin generates media on Voyager's servers with the user's existing Voyager
account, selected workspace and credits. It has no access to the user's computer,
editors or project folders. If the local Voyager plugin is also installed and the
work involves files on this computer, a timeline or an editor, use the local plugin
for that part.

Read the family skill before generating: `voyager-cloud-image`, `voyager-cloud-video`,
`voyager-cloud-audio` or `voyager-cloud-3d`. When a skill isn't already loaded,
read it with `load_skill` and its name; a skill's reference files load the same
way with `file` set to the reference's path.

## Account and credits

A plain request needs no account check first: a generation that the workspace
can't pay for is refused with the reason and a link. Call `account_status` when
the user asks about their plan or credits, or after a billing failure: it reports
the selected workspace, whether generation is included for this user, seat state
and the credit balance.

When credits, plan or seat state don't allow a generation, the tool's error (or an
estimate's reason) says why in one sentence and links the workspace's Voyager plan and
credit details page. Show that sentence and link as given,
then ask how to continue. Never retry on another model to get around it without
asking. On `rate_limited`, wait the time the error gives and retry once.

## Models and settings

Models, supported settings, durations and limits change often: never rely on a
model name, price or limit from memory. Spend at most one discovery call before
the estimate.

- **The user named no model:** generate with the default: omit `model` and the
  generation tool uses it (the result names it). When the request clearly fits a
  recommendation better (a 20-second shot, many references, faces and dialogue,
  clean text in an image), call `list_models` with the `operation` once, use the
  better fit and say why in a few words. With the first result of its kind in the
  conversation, add one line of alternatives from the recommended list, each with
  its reason (for video, for example: "fast and cheap: H3 Max Turbo · atmosphere
  and longer shots: Seedance 2.5 · cinematic realism: FLUX 3 Max"). Don't ask the user
  to choose a model first.
- **Common asks switch the model without a question:** cheaper or faster video →
  H3 Max Turbo; longer than 15 seconds or many references → Seedance 2.5;
  cinematic realism → FLUX 3 Max; faces and spoken dialogue → Veo 3.1; clean text,
  a logo or a transparent background in an image → GPT Image 2.5 Flare. Say why
  in a few words.
- Ask at most one question, and only when something you can't sensibly default
  is missing (a reference the user mentioned but didn't attach, for example).
  Don't batch questions.
- **The user named a model:** use exactly that model, and keep using it for
  follow-ups on the same work until the user names another. Find it with one
  `list_models` call with `query` set to the name. When nothing matches, or the
  name fits more than one entry (a family name, a missing version or tier), say
  so, show the closest entries, and ask once which to use. Never pick a near
  match, a newer or cheaper version, or another provider in its place.
- Never page through the whole catalog and never estimate several models to
  compare them. Never invent a model name or ID, and never switch models because
  another one's settings look simpler. Call `list_models` with `model` only when you need settings
  beyond prompt, duration, aspect ratio and audio.
- Name the model with the result. If Voyager refuses the model, or the job
  reports a different one, stop and ask before going further.

Pass only settings that `list_models` reports for that model: the named tool
inputs where they exist, and any other setting in `parameters` under the field
name the model's listing uses, with every media URL imported with
`import_reference` and replaced by its asset ID.
A
requested setting the model does not support (a duration, aspect ratio or audio
option) is also a question for the user, not a reason to switch models.

## Generate

1. For a plain request, call the generation tool directly; everyone expects media
   to cost credits. Call `estimate_generation` first only when the user asks what
   it will cost, gives a budget, or the job is unusually large (several clips, a
   long video, many images): then show the model and estimated credits and wait
   for their go-ahead. An estimate creates no hold and is not a final price.
2. The generation tool waits up to 20 seconds and returns the job, finished or
   still running.
3. While the job runs, call `get_job` with its ID and `wait_seconds` (up to 25)
   again and again until it succeeds, fails or is cancelled, then show its
   outputs with the model used and the credits charged. Don't end your turn
   while a job you started is still running.

Give every generation call a fresh `client_key`. If a generation call's response
is lost, repeat it with the same parameters and the same `client_key`: Voyager
returns the original job instead of paying twice. Never resubmit with a new key
because a call timed out or a job looks slow: poll the same job with `get_job`. A job in `unknown` state is still being reconciled:
while `get_job` still suggests a poll delay, keep polling the same job. When it
suggests none, stop polling, tell the user the outcome is uncertain, and check
the same job again later. Never start a second paid attempt for it. `list_jobs` finds a job when
the ID is lost. `cancel_job` is best effort: it does not promise a refund, and
credits already spent stay spent. Make no automatic paid retries and no model
switches without the user's agreement; ask before any new paid attempt.

## References and results

References come only from files the user attached in this conversation, HTTPS
URLs they gave you, or a local file the user named when you run on their
computer (a CLI such as Claude Code or Codex). Call `import_reference` for each,
and pass the returned asset IDs to generation tools. For a local file, call
`create_upload` with its name, run the `curl` command it returns with the file's
path, then call `import_reference` with the returned `upload_id`. Never guess
paths on the user's computer, and never look through the user's other files.

Imported references are kept for 7 days and generated results are downloadable
for 30 days. Use `get_asset` for a fresh download link; links expire after a few
minutes, so fetch one when the user needs it instead of pasting an old one.
`delete_asset` deletes an owned asset on request. Give results meaningful
filenames in your reply.

## Brand kits

`list_brand_kits` and `get_brand_kit` read the workspace's brand kits: palette,
typefaces and logo asset IDs. Use them when the user names a brand or asks for
on-brand work: put the palette and type into the prompt, and pass a logo asset ID
as an explicit reference only when the logo should appear. Brand kits are
read-only here; edits happen in Voyager.

## Cast

Cast cards are named, saved characters (or recurring products and props) with a
fixed description and reference images. They persist in the workspace until
deleted and are shared by the user's ChatGPT and Codex connections to the
workspace. They are separate from Cast in the Voyager app's local projects.

- Before making a character, `list_cast` and `get_cast` to reuse a fitting card.
- To make one from scratch, `generate_cast` creates its reference images through
  the normal billed image flow.
- To save attached images as a card, import them, then `save_cast` with a short
  fixed description (face, hair, build, wardrobe; never the medium such as
  "cartoon") and the asset IDs. Saving existing images is not billed.
- To change a card, `save_cast` with its ID and the `expected_version` you read; on
  a version conflict, read it again and reapply the user's change.
  `add_cast_reference` and `remove_cast_reference` change its images;
  `delete_cast` deletes the card, only when the user asks.
- Pass Cast IDs to `generate_image` or `generate_video` on every shot with that
  character, including retakes. Write the action, camera and look around the
  character's name.

## Result cards

Results show as cards with previews and downloads where the host supports them;
otherwise give a short text summary with the job ID, filenames and download links
from `get_asset`. Don't autoplay or describe a result you haven't received.

View saved version →

---
name: voyager-cloud-3d
description: "Cloud: generate 3D models with Voyager from a text description or a reference image, and retexture them."
---

# 3D models

Follow `voyager-cloud` (read it with `load_skill` if it isn't loaded) for account,
models, costs and jobs.

## Generate

1. Choose the model as `voyager-cloud` describes. The default makes a model from
   text, and from a reference image it makes one from the image. For another
   operation pass its `mode` (retexture, rigging, remesh, animations and more,
   all listed by `list_models` with `operation` 3d) and omit `model`.
2. For a specific object, import a clean reference image (one object, plain
   background, the whole object in view) with `import_reference` and pass its
   asset ID in `reference_ids`. To retexture, pass the finished 3D job as
   `source_job_id`. For a concept,
   describe shape, materials, style and intended use (game asset, product shot,
   print) in the prompt.
3. Call `generate_3d` and poll `get_job`. 3D jobs take several
   minutes.
4. Present the preview image and the downloadable formats the job returns (for
   example GLB). Say which format suits the user's tool; don't promise rigging,
   animation or formats the job did not return.

View saved version →

---
name: voyager-cloud-audio
description: "Cloud: generate narration with premade or existing Voyager voices, music and sound effects."
---

# Speech, music and sound effects

Follow `voyager-cloud` (read it with `load_skill` if it isn't loaded) for account,
models, costs and jobs. Audio jobs run
in the background: poll `get_job` and present the player and download when done.

## Narration

1. `list_voices` lists premade voices. Choose one that fits the script's audience
   and tone, or the voice the user names; offer two or three when the voice is
   open and it matters.
2. `list_voices` with `source` set to `mine` lists the user's existing cloned
   voices when their plan includes voice cloning. This plugin never creates,
   records or re-records a voice clone; if the user wants one, say it is made in
   the Voyager app, where they give their own consent.
3. Write the script for the ear: short sentences, numbers and names written as
   spoken. Then `generate_speech` with the text, voice and the
   speech model chosen as `voyager-cloud` describes.
4. Listen-check claims honestly: report what you heard only if you could check it.

## Direct the delivery

- Emotion written as narration ("she said sadly") is spoken aloud. Direct delivery
  with the markup the chosen speech model supports, such as bracketed tags
  (`[whispering, playful]`), only where `list_models` or the model's description
  says it accepts them; otherwise write the line so its wording carries the tone.
- Ellipses add a pause and weight; capitals add emphasis. Don't use SSML.
- Delivery works best when the voice already has it; a calm narrator will not
  shout well.

## Music

Describe genre, tempo, instruments, mood and structure in the prompt, and whether
it is instrumental (a bed under speech or picture should be). Narrate the
arrangement ("start with just piano, then bring in drums"). Never ask for a
particular song's melody, lyrics or an artist's voice. Exact cue timing is never
guaranteed. Call `generate_music` with a duration that fits the
use and the limits `list_models` reports for the chosen model.

## Sound effects

- One sound per prompt. Write a short sequence in order ("footsteps on gravel,
  then a metal door opens"); make longer scenes as several cues.
- Name the sound's kind: impact, whoosh, ambience, one-shot, loop, braam, glitch,
  drone, plus tempo and key for musical hits.
- Set a duration or looping only when `list_models` reports that setting and its
  range for the model; otherwise let the model choose.
- Deliver the format the job returns and name it in your reply; this plugin does
  not convert or mix audio.

Generate each cue with `generate_sound_effect`, named by cue (`reveal-hit`,
`ui-click-01`), and list the delivered files with their intended cue times.

View saved version →

---
name: voyager-cloud-image
description: "Cloud: generate or edit still images with Voyager, including branded images and images of saved Cast characters."
---

# Images

Follow `voyager-cloud` (read it with `load_skill` if it isn't loaded) for account,
models, costs and jobs.
Choose the image model as `voyager-cloud` describes. Honor an explicit size,
aspect ratio, count and quality; otherwise make one square image.

## Source real subjects

For a real subject, use the first usable source: the user's asset (brief,
attachments in this conversation or a brand kit), then the
subject's official source or open libraries/stock, then generation when exact
structure or labels are not required, then a hand-built depiction labeled
schematic. The user's explicitly requested version wins; a guessed asset type
is not such a request. Abstract or invented subjects are made freely. Follow the
runtime's likeness, licensing and factual-claim boundaries.

## Recurring characters

For a character across several images, use a Cast card as `voyager-cloud`
describes and pass its ID with `generate_image` on every image, edits included.
Additional style, composition or edit references stay explicit asset IDs.

## Exact words, logos and layouts

Image models misspell and redraw. When the brief needs exact words, a real logo
or several sizes, generate the picture without lettering and say that exact text
and layout are finished in a design tool; pass a real logo only as an imported or
brand-kit asset ID, never redrawn from memory. A thumbnail may heighten the real
story; it should not imply events the video never contains.

## Generate or edit

Write the prompt as subject, action, setting, composition, light and look. For an
edit, import the image with `import_reference`, pass its asset ID and describe
only the change and what must stay the same. Say which reference does what when
there are several ("image 1 sets the look; image 2 is the product"). Show every
output; offer one targeted retake rather than a batch of guesses.

## The style key wins over photo references

Image models follow a photo more readily than words: given a photo of a person
and "line art", they tend to return a photo of the person. Once a style is set
(a requested look such as line art or a storyboard sketch, or a style key image),
hold it:

- For a recurring character, pass Cast IDs on every
  image/video estimate and run. The adapter adds its fixed description, refs
  and model token mapping. Write shot action, composition, camera, look and
  sound around the character's name; do not invent numbered Cast-ref tokens.
- Pass a photo only for identity: the face, hair, wardrobe, a product's shape and
  markings, a prop. Say which image does what, and that the photo does not set
  the look: "Use image 2 only for the woman's face, hair and coat. Draw the whole
  frame as loose black line art on white, like image 1, not as a photograph."
- Pass the style key image, when there is one, with every frame, and repeat its
  words in every prompt. A shot under a film's scoped look (a photoreal
  flashback) takes that look's image and words instead.
- Before accepting a frame, compare it with the look that applies to it: the
  same medium, line, fill, texture and palette. A frame that matches its scoped
  look is not a failed take. A frame that drifted toward the photo is a
  failed take, not a variant. Keep the same `cast` IDs and strengthen the style
  direction on a correction. Do not drop identity refs or substitute text-only
  identity. Report
  likeness results separately from style inspection: a face match can still be
  off-look, and an unavailable check is not a match.

## Brand and type

- [Typography](references/typography.md) for any lettered image.
- [Color and brand](references/color-and-brand.md) for named brands, brand kits and contrast.

When these files aren't available, read them with `load_skill` for this skill and
`file` set to the path.

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

View saved version →

---
name: voyager-cloud-video
description: "Cloud: generate short AI video clips with Voyager from a prompt, a start image or references, including saved Cast characters."
---

# Short videos

Follow `voyager-cloud` (read it with `load_skill` if it isn't loaded) for account,
models, costs and jobs. This plugin
makes short clips one at a time. Editing, cutting several clips together, titles and
timelines are not available here; if the local Voyager plugin is installed, use it
for that.

## Real product UI is never generated

Never generate a real app's screens, a website or a real product's interface:
models invent text and controls. Ask for a real screen recording or screenshot
and use it as a reference, or show the product in an abstract way.

## Generate a clip

1. Choose the video model as `voyager-cloud` describes: exactly the model the
   user named, otherwise the default (omit `model`). For a clip from a still the
   recommended image-to-video model takes the start image. Use only durations,
   aspect ratios, references and audio options the model supports, and pass a
   start image or other references as asset IDs in `reference_ids` or in the
   reference fields the model lists.
2. For a clip from a still, make or import the still first and show it; animate
   the still the user approved, and spend the video prompt on action and camera.
3. Pass Cast IDs for every recurring character on every clip and retake.
4. Call `generate_video` and poll
   `get_job`. Video takes minutes: tell the user it is running and poll the same
   job; never submit it again because it is slow.

## Inspect and deliver

Look at the result before presenting it: check the subject, motion, the
character's likeness and any requested words. A clip that drifted from the
approved still or Cast look is a failed take; say what failed and offer one
retake with a corrected prompt. Deliver with the download from `get_asset`.

## Exclusions

Every generated clip risks the same defects. Exclude this base set unless the
brief wants one of them: on-screen text and signage, logos, watermarks, morphing
(objects or bodies changing shape), extra limbs or objects, glow, particles and
lens flares, and palette drift. Use a negative-prompt field only when the model's `list_models` settings
  include one, passing it in `parameters` with the base set and any scene
  exclusion as nouns. Otherwise describe the
  wanted state ("an empty, dry street", "plain unmarked storefronts", "colours
  steady from start to end"); a brief closing line of exclusions ("No umbrellas,
  no shop signs.") is fine. Never describe the unwanted thing positively to limit
  it ("only two or three umbrellas", "one woman with a red umbrella", drizzle),
  and keep it out of the keyframe stills: what the prompt or a still shows, the
  model renders.

## The style key wins over photo references

Image models follow a photo more readily than words: given a photo of a person
and "line art", they tend to return a photo of the person. Once a style is set
(a requested look such as line art or a storyboard sketch, or a style key image),
hold it:

- For a recurring character, pass Cast IDs on every
  image/video estimate and run. The adapter adds its fixed description, refs
  and model token mapping. Write shot action, composition, camera, look and
  sound around the character's name; do not invent numbered Cast-ref tokens.
- Pass a photo only for identity: the face, hair, wardrobe, a product's shape and
  markings, a prop. Say which image does what, and that the photo does not set
  the look: "Use image 2 only for the woman's face, hair and coat. Draw the whole
  frame as loose black line art on white, like image 1, not as a photograph."
- Pass the style key image, when there is one, with every frame, and repeat its
  words in every prompt. A shot under a film's scoped look (a photoreal
  flashback) takes that look's image and words instead.
- Before accepting a frame, compare it with the look that applies to it: the
  same medium, line, fill, texture and palette. A frame that matches its scoped
  look is not a failed take. A frame that drifted toward the photo is a
  failed take, not a variant. Keep the same `cast` IDs and strengthen the style
  direction on a correction. Do not drop identity refs or substitute text-only
  identity. Report
  likeness results separately from style inspection: a face match can still be
  off-look, and an unavailable check is not a match.