Google Veo

Google Veo is Google DeepMind’s family of video generation models, built on a latent diffusion transformer that turns a text prompt, a reference image, or a start/end frame pair into a short video clip with sound baked in. First shown at Google I/O 2024 as a silent, 1080p text-to-video model, Veo reached its current form as Veo 3.1, released October 15, 2025: an 8-second, up-to-4K generator that produces natively synchronized dialogue, sound effects, and ambient audio in the same call as the video, no separate audio pass required. It ships across four surfaces, the consumer-facing Flow editor, the Gemini app, the Gemini API, and Vertex AI, putting it in direct competition with Sora, Kling, and Seedance for the same generative-video market.

Release Timeline: From Silent Clips to Native Audio

Veo’s four major releases each added one capability that the previous generation lacked, a pattern common to the fast-moving video-generation field:

Google DeepMind CEO Demis Hassabis framed Veo 3’s audio jump as the moment “AI video generation left the era of the silent film,” a milestone competitors matched within months: OpenAI’s Sora 2 shipped native synced audio on September 30, 2025.

What Veo 3.1 Actually Generates

Beyond raw text-to-video, Veo 3.1 added a set of narrative-control features aimed squarely at the biggest complaint about earlier video models: a generated character’s face, outfit, or a product’s exact shape drifting between shots.

flowchart LR
    classDef default fill:#ffffff,stroke:#4338CA,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef data    fill:#EEF0F7,stroke:#0D9488,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef process fill:#F7F8FC,stroke:#6366F1,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef output  fill:#4338CA,stroke:#4338CA,stroke-width:2px,color:#ffffff,rx:8px,ry:8px;

    A["Prompt + up to 3\nreference images"]:::data --> B["Ingredients-to-Video:\nlock character/object identity"]:::process
    C["First frame + last frame"]:::data --> D["Guided transition\nbetween the two"]:::process
    E["Prior 8s clip"]:::data --> F["Scene Extension:\ncontinue from final second"]:::process
    B --> G["Latent diffusion transformer\n(video + audio jointly denoised)"]:::process
    D --> G
    F --> G
    G --> H["8s clip, up to 4K,\nwith synced audio"]:::output

• Ingredients-to-Video: up to three reference images anchor a character, object, or scene’s visual identity across a generation, the model’s answer to the “different face every shot” problem that plagues prompt-only video generation.
• Scene Extension: a new clip is generated starting from the final second of the previous one, letting a user chain 8-second segments into a continuous minute-plus sequence rather than a single isolated clip.
• First-and-Last-Frame Guidance: supply a starting image and an ending image, and Veo generates the transition between them, audio included, useful for match-cuts and product reveals.
• Camera Controls: explicit framing and motion instructions, zoom, pan, tracking, rather than relying on whatever camera behavior the model defaults to from the prompt alone.
• Outpainting and object edit: expanding a frame’s boundaries, or inserting and removing objects from an existing clip, without regenerating the whole shot.

# Scenario: a brand wants the same mascot character consistent
# across three separate ad clips, using Ingredients-to-Video.
from google.genai import types

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt="The mascot waves at the camera, then walks toward a display shelf",
    reference_images=[open("mascot_front.png", "rb").read(),
                       open("mascot_side.png", "rb").read()],
    config=types.GenerateVideosConfig(aspect_ratio="16:9", resolution="1080p"),
)

Architecture: A Latent Diffusion Transformer, Jointly Denoising Video and Audio

Veo compresses raw video (and, from Veo 3 onward, audio) into a lower-dimensional latent space with an autoencoder, then runs a transformer-based diffusion process that iteratively denoises that latent representation until it resolves into a coherent clip. Operating in latent space rather than on raw pixels is what makes generating several seconds of high-resolution video computationally tractable at all; the same trick underlies Stable Diffusion for images. What distinguishes Veo 3 and 3.1 from Veo 2 is that video and audio are denoised jointly rather than as two separate pipelines stitched together afterward, which is why the dialogue Veo generates lines up with lip movement and sound effects land on the frame where the on-screen action actually happens, rather than being dubbed on top after the fact.

Model Tiers and Pricing: Lite vs. Fast vs. Standard

The Gemini API prices Veo 3.1 per second of successfully generated output, split across three tiers that trade cost for fidelity and resolution ceiling:

An 8-second clip therefore ranges from $0.40 (Lite, 720p) to $4.80 (Standard, 4K), an order of magnitude spread for the same prompt. The widget below makes that trade-off concrete: pick a tier, a resolution, and a duration, and see the per-clip cost.

Veo vs. Sora vs. Kling vs. Seedance

The Sora row reflects a genuinely unusual moment in this comparison: OpenAI announced in March 2026 that it was shutting down the standalone Sora consumer app (closed April 26, 2026) after user numbers collapsed from roughly a million to under 500,000 against roughly $1 million a day in running costs, and its developer API is scheduled to shut down on September 24, 2026, folding the underlying Sora 2 model back behind ChatGPT rather than offering it as a standalone product or API. Veo, by contrast, has expanded its surface area over the same period, adding the Lite tier and deepening Vertex AI integration for enterprise customers, a divergence in strategy as much as capability.

What’s New (2025-2026)

Veo 3’s May 2025 audio launch and Veo 3.1’s October 2025 narrative-control features (Ingredients-to-Video, Scene Extension, first/last-frame guidance) were the two biggest jumps in the line’s history, taking Veo from “another text-to-video model” to a tool aimed at people directing multi-shot sequences rather than generating one-off clips. March 2026 brought Veo 3.1 Lite, a cost-tier response to competitive pressure from cheaper aggregators and rival models, explicitly pitched at developers building high-volume, iterate-fast video applications rather than single hero shots. Over the same window, third-party platforms like Higgsfield absorbed Veo into multi-model routing layers that let a user or an automated pipeline pick Veo, Sora, Kling, or Seedance per shot depending on which model’s strengths, Veo’s 4K ceiling and audio-video sync, best fit a given clip, evidence that the aggregation layer, not any single model, is where a growing share of production video workflows now sit.

Where It Fits

Veo is the strongest choice when a project needs the highest resolution ceiling in the category (4K, versus 1080p for Sora and Seedance), tight audio-video synchronization out of the box, or deep integration with Google Cloud and Vertex AI for enterprise deployment. Its Ingredients-to-Video and Scene Extension features specifically target continuity, the same character or product staying visually consistent across multiple shots, which matters more for ad campaigns and short-form narrative content than for single stand-alone clips. Teams that need one model’s specific strengths and are comfortable managing the Google Cloud relationship directly are the best fit for calling Veo natively; teams producing high volumes of varied video across several competing models, where the best model changes shot to shot, are better served by an aggregation layer like Higgsfield sitting in front of it.

# Scenario: an e-commerce backend generates a short vertical
# product video automatically whenever a new SKU photo is uploaded.
import time
from google import genai
from google.genai import types

client = genai.Client()

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt="Sneakers rotating on a pedestal, studio lighting, 35mm lens",
    config=types.GenerateVideosConfig(
        aspect_ratio="9:16",
        resolution="1080p",
        duration_seconds="8",
    ),
)

# Video generation is a long-running operation; poll until it's done
while not operation.done:
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video, destination="product.mp4")