The first time a teammate called the Veo endpoint, he pinged me to say the API was broken. It had returned a long operation name and no video. Nothing was broken. Video generation on Vertex AI runs as a background job, so the call hands you a ticket to poll, not a file to download. That one detail trips up almost everyone who arrives from the image side, where a request returns pixels in a second or two.

This part is a map of the generative media stack on Vertex AI: images, video, speech, and music, plus the work Gemini does itself. I will tell you which model to reach for, what each one costs where I can pin a real number, and the two mistakes that cost the most.

Five families of generative media, one platform

Vertex AI is Google Cloud’s managed platform for building with foundation models. In 2026 Google started branding the surface as the Gemini Enterprise Agent Platform, but the endpoints and model IDs you call did not change, so I will keep saying Vertex AI here to match the rest of this series. Generative media splits into five model families, and the split matters because you pick the family before you pick anything else.

Gemini is the multimodal model line you met in Part 3. It reads images, audio, and video as input, and one variant, Gemini 2.5 Flash Image, generates and edits images directly. That variant picked up the nickname Nano Banana during its preview and the name stuck. Imagen is the dedicated text to image family, now on Imagen 4, tuned for photorealism and for legible text inside the picture. Veo is the text and image to video family, on Veo 3.1, which returns short clips with audio. Lyria is the text to music family, generally available as Lyria 2 with a newer Lyria 3 line. Chirp is the speech family, on Chirp 3, which reads text aloud in around 35 languages and can build a custom voice from roughly ten seconds of sample audio. That is the whole board.

Nano Banana or Imagen 4 for images?

Two families make still images and they do not overlap cleanly. Gemini 2.5 Flash Image works inside a conversation. You send a prompt, get an image, then say make the shoe blue and keep the same model, and it edits the picture while holding character and style steady across turns. It can also fuse several input images into one. That consistency is the reason to pick it. Imagen 4 is a dedicated one shot renderer, strong on photorealism and on getting readable text into the frame, and it is built for batch jobs where each request stands alone.

Pricing is where the two diverge in a way that shapes design. Gemini 2.5 Flash Image bills by output tokens, and each image is 1,290 output tokens at 30 US dollars per million, so one image costs about 0.039 US dollars. Imagen 4 bills per generated image on its own schedule, which you should confirm in the console before you commit a batch, because at high volume a few tenths of a cent per image decides the monthly bill. My rule: reach for Nano Banana when you are iterating, editing, or need the same character across shots, and reach for Imagen when you want a clean one shot render at scale. Do not run a 100,000 image nightly batch through a conversational model out of habit; price both first.

flowchart TD
  A[What are you generating?] --> B[Still image]
  A --> C[Video]
  A --> D[Speech]
  A --> E[Music]
  B --> F[Need editing or consistency?]
  F -->|Yes| G[Gemini 2.5 Flash Image]
  F -->|No, one shot batch| H[Imagen 4]
  C --> I[Veo 3.1, async poll]
  D --> J[Chirp 3]
  E --> K[Lyria]

How a video request actually runs

Veo does not answer in one call. You submit a prompt, optionally with up to three reference images to anchor a character or a look, and the endpoint returns an operation name with a done flag set to false. That is the long running prediction pattern. Your code then polls the operation until done turns true, and only then does the result carry a video, usually as a Cloud Storage URI you fetch or a set of bytes. Veo 3.1 returns eight second clips with audio, so a storyboard is several clips stitched downstream, not one long generate call.

Design around the wait. A generation takes minutes, not the second or two an image takes, so a synchronous request thread is the wrong shape. Queue the job, store the operation name, and let a worker poll or a webhook style check pick it up. That keeps a web request from hanging on a model that is still rendering.

Image cost scales linearly off that 0.039 US dollars per image figure, which makes the monthly number easy to predict once you know your volume. Here is the curve from a thousand images to fifty thousand.

Speech and music without a studio

Chirp 3 is the speech family. It reads text aloud in around 35 languages and, with Instant Custom Voice, builds a usable custom voice from roughly ten seconds of sample audio. That is genuinely useful for narration, IVR prompts, and accessibility, and it is fast enough to stream. It is also the feature that needs the most care, because cloning a voice from a short sample raises a consent question. Get written permission for any real person’s voice, and do not let a product ship that clones a customer without a clear opt in.

Lyria is the music family. Lyria 2 is generally available and generates high fidelity instrumental music across styles, with a newer Lyria 3 line for higher quality work. I treat generated music as scratch and background material, useful for prototypes, internal videos, and placeholder soundtracks, and I keep a human in the loop before anything with a brand on it goes public. Like every media model here, Lyria and Chirp output carries a SynthID watermark by default.

A cost model for a product catalog

Say you run a catalog and want a fresh studio style image for 10,000 products each month, generated with Nano Banana. One shot each is 10,000 times 0.039, so 390 US dollars. The catch is that nobody ships the first generation. Add one edit pass per product to fix a color or a crop and you have doubled the generations to 20,000, or 780 US dollars. Offer three variations per product for an A B test and you are at 40,000 generations, 1,560 US dollars. The model is cheap per image; the iteration policy is what sets the bill.

Generate, watermark, and keep it in policy

Three controls matter before generated media leaves your account. First, provenance: every image, video, and audio clip from these models carries a SynthID watermark by default, an invisible signal you can check later to confirm a Google model made the asset. Second, safety: run prompts and outputs through the filters and Model Armor covered in Part 14, because media prompts carry the same injection and policy risks as text. Third, grounding to your brand: pass reference images so Veo and Nano Banana hold a product or a character steady instead of inventing a new one each call. Store finished assets in Cloud Storage and keep the operation name and prompt with them for audit.

The snippet below generates a product image synchronously, then kicks off a Veo clip and polls it. It uses the unified google-genai SDK pointed at Vertex.

from google import genai
from google.genai import types
import time

client = genai.Client(vertexai=True, project='my-project', location='us-central1')

# 1. Product image with Gemini native, returns almost immediately
img = client.models.generate_content(
    model='gemini-2.5-flash-image',
    contents='Studio photo of a red running shoe, white seamless background',
)
png_bytes = img.candidates[0].content.parts[0].inline_data.data  # SynthID watermarked

# 2. Veo clip, a long running job you must poll
op = client.models.generate_videos(
    model='veo-3.1-generate-001',
    prompt='Slow drone shot over a coastal road at sunrise',
    config=types.GenerateVideosConfig(number_of_videos=1),
)
while not op.done:
    time.sleep(15)          # minutes, not seconds
    op = client.operations.get(op)

print(op.result.generated_videos[0].video.uri)

Expected output: step 1 sets png_bytes to watermarked image data in about a second; step 2 prints a Cloud Storage URI once the poll loop finishes, usually after a few minutes. Failure mode: skip the while loop and read op.result immediately and it is empty, because op.done is still false; name a region or model your project cannot use and you get a 404 or a permission error before any generation starts.

When should Gemini read media instead of make it?

Generation is half of multimodal. The other half is understanding, and Gemini does it in the same call you already use. Send an image, a PDF page, an audio clip, or a short video as input next to your text prompt, and Gemini describes it, pulls out fields, transcribes it, or answers questions about it. That covers work people often reach for a separate service to do: reading a receipt, tagging a product photo, summarizing a recorded call, or checking whether a generated image actually matches the brief.

This changes how I build a media pipeline. Generate with Nano Banana or Veo, then send the result back to Gemini to grade it against the prompt before a human ever sees it, an automatic first pass that catches the obvious misses. Understanding is billed as ordinary input tokens, so it is cheap next to generation, and it keeps one model and one SDK in the loop instead of bolting on a separate OCR or transcription vendor. When the job is read this and tell me something, that is Gemini understanding. When the job is make something new, that is Imagen, Veo, Lyria, or Chirp. Keeping that line clear is the fastest way to pick the right call.

Nano Banana for images, Veo only when video earns it

Here is where I land after running this stack. For product and marketing images, default to Gemini 2.5 Flash Image, because the editing loop and character consistency save more time than the per image price ever costs, and switch to Imagen 4 only when you have a clean high volume one shot batch and have confirmed its per image price beats the token math. For video, reach for Veo 3.1 only when a moving clip clearly beats a still, since it is asynchronous, slower, and more expensive per asset, and design the polling before you write the prompt. For narration and soundtracks, Chirp 3 and Lyria are ready, with a written consent gate on any cloned voice. Across all of it, leave SynthID on and route through your safety filters.

Once you are generating media at volume, the next question is how you watch it in production: latency, error rates, and cost per asset over time. That is the next part on observability. Before you move on, price one real batch of your own images against both the token math and Imagen, and write the number down.

Compare with the same layer on another cloud: vision, audio, image, and document models on Azure OpenAI.

References

• Announcing Veo 3, Imagen 4, and Lyria 2 on Vertex AI
• Use Gemini 2.5 Flash Image (Nano Banana) on Vertex AI
• Veo model documentation, Vertex AI
• Vertex AI generative AI models list

About The Author

Dr. Pranay Jha

Dr. Pranay Jha is a Cloud and AI Consultant with 18+ years of experience in hybrid cloud, virtualization, and enterprise infrastructure transformation. He specializes in VMware technologies, multi-cloud strategy, and Generative AI solutions. He holds a PhD in Computer Applications with research focused on Cloud and AI, has published multiple research papers, and has been a VMware vExpert since 2016 and a VMUG Community Leader.

See author's posts