Generation and render

This page covers the two ways media gets made: generating still images and video clips from a prompt, and rendering a finished creative from a template.

Generation: images and video from a prompt

Generation produces a still image with Gemini 3.1 Flash Lite Image or a video clip with Gemini Omni (Veo as a per-campaign fallback) from a text prompt, runs it on your Organization's own Google Cloud project, and drops the finished file into your asset library as a frozen, read-only asset.

It is built to run asynchronously: a request is queued, a worker carries it out, and video, which is slow, is polled to completion. Each job moves through queued, running, and then succeeded, failed, or canceled. A queued job can be canceled before anything is billed. A running job can be stopped too: the provider's work so far is abandoned (not unwound), and the job settles as canceled so a stuck generation stops blocking its scene, storyboard video, or render. A stop button appears wherever a generation or render is in flight.

A job or render with no progress for over five minutes counts as stuck: healthy work reports in more often than that, so silence means its background task chain was lost. When that happens a "Recover stuck work" action appears (on the campaign's Generate and Render matrix steps, and in the Render Queue): one click re-arms every lost poll and wait in your Organization, so work that actually finished settles with its real result and work that truly hung fails honestly with a retry offered. Recovery never bills anything new; only an explicit retry or re-render does.

What works today

The generation pipeline works end to end against live providers: image generation through Gemini 3.1 Flash Lite Image, and video generation through Gemini Omni or Veo, both billed to the Organization's Google Cloud project, with the output frozen into the asset library. Platform admins can watch generation jobs on the monitoring console, and jobs show up in the activity feed.

Two video models

Gemini Omni is the default video model: it assembles a storyboard's scenes into one generation with real scene-to-scene cuts, verified live end to end. Veo remains available as a per-campaign fallback in Campaign settings; it takes the whole storyboard as a single prompt and returns one continuous clip capped at 8 seconds, with weaker cuts between scenes. If video generation misbehaves on a campaign, switching it to Veo is the safe fallback.

Generate from the Generate step

You trigger generation from a campaign's Generate step: the storyboard assembles into one video clip. On the Storyboard step each scene can also get a fast still as an image preview; previews are only for you and never end up in a render. Generation conditions on the sample items' linked images as references. The finished combination packages then go through the render step below.

Voiceover

When a template's audio field binds the storyboard voiceover, Klyo generates a narrator track from the storyboard itself. Each scene's voiceover line is the script: Gemini text-to-speech reads them, in scene order, into one spoken track.

You set the binding on the Package step, where an audio field's fill source offers "Storyboard voiceover" alongside pinning a library track. The voiceover speaks the campaign's language, set in Campaign settings alongside the video model and the voice. A language change applies on the next generation, not to a track already made, so regenerate to hear it.

On the Generate step a voiceover card appears once the binding is set. Generate the sample voiceover there, play it back, and regenerate for another take (a regenerate bills the text-to-speech again). The sample render waits on this voiceover, so generate it before rendering the sample.

On the matrix fan-out every combination generates its own voiceover from its own resolved scene lines, so a script with {{variables}} reads each cell's real values. Generation refuses a line that still carries an unresolved variable rather than speaking the literal braces, so fix or remove any leftover token in the storyboard first.

Render: a finished creative from a template

Rendering takes a combination package, its template version, and its filled inputs, and produces a finished video or image through Creatomate.

Rendering is built

Rendering is connected (record 0081) and fans out per combination (record 0099). From a campaign's Render matrix step you trigger the sample proof render that checks the template, then fan the matrix out. A template whose video field binds the storyboard generates its own fresh clip per combination, composed from that cell's own catalogue items; every cell also carries its own catalogue item images and ad copy. The finished video freezes into the asset library. The Review console plays each Final Video so you can approve, reject, or re-render it, one cell or in bulk. Approved combinations then activate: pushed to YouTube or handed off as a Google Ads or DV360 pack (Activation). The cross-channel roll-up over the pulled metrics is the frontier still ahead.

The cost estimate

Before you fan the matrix out, the confirm dialog estimates what the run will spend. It is a rough figure from flat per-item rates, not live provider pricing, broken into up to three lines:

• Renders: one render credit per combination, always present.
• Generated videos: one generated clip per combination, shown when the template's video field binds the storyboard (priced at the chosen resolution).
• Generated voiceovers: one narrator track per combination, shown when an audio field binds the storyboard voiceover.

The sample is already rendered, so the estimate covers the rest of the matrix. The real bill depends on each clip's length and the provider's current rates. The spend lands on your organization's own provider accounts (its Google Cloud project for inference and its own render subscription), never on a personal card.

How the pieces fit

Storyboard ──generate──▶ a fresh video per combination
                       + per-scene image previews (never in a render)
Combination Package + Template version + inputs ──render──▶ Final Video (Creatomate)
Final Video ──review──▶ approved / rejected / re-rendered

The design principle behind both is "own the engine, rent the render": Klyo keeps the orchestration, prompts, and assets, and rents only the raw generation and render steps from providers it can swap out later.

What you can do today

• Generate a scene's image preview, or every scene's at once, from the Storyboard step, conditioned on the sample items' linked images as references.
• Run image and video generation against live providers (through the API and the admin monitoring console), with results frozen into the asset library.
• Choose a campaign's video model (Gemini Omni or Veo) in Campaign settings, plus the source-clip resolution Veo generates at (Omni derives its own from the prompt) and the voice reading the voiceover.
• Generate a narrator voiceover from the storyboard's scene lines when an audio field binds it, one track for the sample and a fresh one per combination, in the campaign's language set in Campaign settings.
• Render the sample and fan the matrix out into Final Videos through Creatomate, getting a freshly generated clip per combination when the template's video field binds the storyboard.
• Approve, reject, or re-render each Final Video, one cell or in bulk, from the Render Queue or the Review console.
• Inspect template structure and history (see Templates).

Not available yet

• The cross-channel roll-up that joins the pulled metrics across networks into one comparison. The nightly KPI pull that feeds it is built for owned YouTube uploads and for Tracked Campaigns and ships switched off by default; the roll-up over that data is the frontier still ahead.