How Well Does Omni Flash Hear 'Rotate the Camera 30 Degrees Right'? Measuring Where Conversational Edits Land

The minimal edit loop

First, a thin wrapper that applies one edit. Omni Flash video editing is public preview, and the exact call name may change. I keep the edit itself inside the function and expose the subject of this article — verification and the cost ledger — on the outside.

from dataclasses import dataclass, field
from pathlib import Path
 
OMNI_FLASH_MODEL = "gemini-omni-flash"   # public preview
PRICE_PER_OUTPUT_SEC_USD = 0.10          # $0.10 per output second
 
@dataclass
class EditResult:
    instruction: str
    out_path: Path
    out_seconds: float
    landed: bool = False
    confidence: float = 0.0
    note: str = ""
 
def omni_flash_edit(client, base_video: Path, instruction: str,
                    out_dir: Path) -> EditResult:
    """Apply one conversational edit; return the output path and duration.
    The exact edit API is public preview and may change, so it is
    isolated inside this function.
    """
    resp = client.videos.edit(              # preview: name may change
        model=OMNI_FLASH_MODEL,
        video=str(base_video),
        instruction=instruction,
    )
    out = out_dir / f"edit_{abs(hash(instruction)) % 10_000}.mp4"
    out.write_bytes(resp.video_bytes)
    return EditResult(
        instruction=instruction,
        out_path=out,
        out_seconds=float(resp.duration_seconds),
    )

Carrying back the duration (out_seconds) is the crux. Billing is proportional to output seconds, so without recording it here you cannot reproduce cost later.

Have Gemini compare the before and after frames

Now the main event: verification. Pull one representative frame from the video, hand the two frames plus the instruction to gemini-3.5-flash, and receive whether it landed as structured JSON.

import json, subprocess
from pydantic import BaseModel
 
class EditVerdict(BaseModel):
    landed: bool
    confidence: float   # 0.0 to 1.0
    note: str
 
def grab_frame(video: Path, at_sec: float, out: Path) -> Path:
    # Pull a single representative frame (default near the middle)
    subprocess.run(
        ["ffmpeg", "-y", "-ss", str(at_sec), "-i", str(video),
         "-frames:v", "1", str(out)],
        check=True, capture_output=True,
    )
    return out
 
def verify_edit(client, before_png: Path, after_png: Path,
                instruction: str) -> EditVerdict:
    prompt = (
        "These two images are before/after representative frames of a video.\n"
        f"Requested edit: \"{instruction}\"\n"
        "Judge whether this edit is actually reflected in the second image.\n"
        "If you are not confident, lean toward landed=false."
    )
    resp = client.models.generate_content(
        model="gemini-3.5-flash",
        contents=[
            prompt,
            {"inline_data": {"mime_type": "image/png",
                             "data": before_png.read_bytes()}},
            {"inline_data": {"mime_type": "image/png",
                             "data": after_png.read_bytes()}},
        ],
        config={
            "response_mime_type": "application/json",
            "response_schema": EditVerdict,
        },
    )
    return EditVerdict(**json.loads(resp.text))

The single line that tips low-confidence verdicts toward "not reflected" quietly supports every later decision. Counting a miss as a landing is the worst side — it adopts a failed edit as-is — so that is the one place I stay conservative.

Measured — which instructions land, and where they fall off

Against three 8-second promo clips, I applied 42 edit instructions of varying kinds and measured the landing rate with the loop above. Confidence below 0.6 counts as not reflected. These are tendencies for my footage and my prompts; they move as the environment changes.

A clear tendency emerged. Global appearance changes (lighting, color, weather) land readily, while spatially precise asks (angle, position, size) often miss. Subject swaps sit in between — they land more often when phrased by role or attribute rather than fine identity.

Looking at the misses, precise angle asks split mostly into "pushed in slightly" and "replaced with a completely different shot," and the more I carved the instruction into numbers, the less it hit. Here, stating the intent in words rather than leaning on figures (30 degrees, 20%) gave more stable results.

Before / After — editing by eye vs. editing behind a verification gate

Once you know the landing rate, the shape of the workflow changes. The old way was "stack edits until it looks good," which charges you for misses too and never tells you how many rounds it will take.

# Before: stack until it "looks good" — cost is unreadable
def edit_until_ok(client, base, instructions, out_dir):
    cur = base
    for ins in instructions:
        r = omni_flash_edit(client, cur, ins, out_dir)
        cur = r.out_path           # stack the next one without checking
        # a human plays the video and judges by eye ... misses billed too
    return cur

Replace that with a version that verifies each edit, restates a missed instruction up to a retry cap, and declines to adopt it if it still will not land.

# After: keep only edits that landed, and post cost to a ledger
@dataclass
class CostLedger:
    spent_usd: float = 0.0
    wasted_usd: float = 0.0            # lost to non-landing edits
    kept: list = field(default_factory=list)
 
    def charge(self, r: EditResult):
        cost = r.out_seconds * PRICE_PER_OUTPUT_SEC_USD
        self.spent_usd += cost
        if r.landed:
            self.kept.append(r)
        else:
            self.wasted_usd += cost
 
def edit_with_gate(client, base, instructions, out_dir,
                   max_retry=1, conf_floor=0.6):
    cur, ledger = base, CostLedger()
    for ins in instructions:
        attempt, landed = 0, False
        while attempt <= max_retry and not landed:
            r = omni_flash_edit(client, cur, ins, out_dir)
            mid = r.out_seconds / 2
            before = grab_frame(cur, mid, out_dir / "b.png")
            after = grab_frame(r.out_path, mid, out_dir / "a.png")
            v = verify_edit(client, before, after, ins)
            r.landed = v.landed and v.confidence >= conf_floor
            r.confidence, r.note = v.confidence, v.note
            ledger.charge(r)
            if r.landed:
                cur, landed = r.out_path, True
            attempt += 1
        if not landed:
            print(f"Declined: {ins} (final confidence {r.confidence:.2f})")
    return cur, ledger

Running both across three clips, the by-eye method took 18 edits for 12 keepers, with about 31% of spend lost to misses. The gated method reached the same goals in 14 edits, and because it declined misses early, waste stayed around 12%. In money, at $0.80 per 8-second clip edit, that gap compounds.

Tracks are preserved, but repeated edits loosen the sync

As the preview notes promise, the audio track survived editing. But there is a production gotcha I hit. Stack three or four edits and the video-side duration can drift slightly, and each time, the lip movement and narration drifted a little out of sync. Negligible on a single edit, it becomes noticeable in a promo video once it accumulates.

As a workaround, I cap edits that do not touch audio at three; beyond that I strip the audio, finish the video alone, then lay the narration back on at the end. Sync does not degrade monotonically with edit count, but planning as if more rounds tend to loosen it keeps you safe.

One more thing: I defaulted the verification frame to a single one near the middle, but for videos with cuts, raising it to three frames — head, middle, tail — stabilized the judgment. A single frame occasionally misses the exact interval where the change occurred.

How I use it in indie development — lean toward instructions that land

Having measured it, my operating policy is clear. Design promo-video finishing around the instructions that land (lighting, color, weather, attribute-based subject swaps), and settle spatially precise choices in the framing at generation time, not in the prompt. Trying to fix angle or prop placement afterward with numbers only increases the billed misses.

In my case, promo videos for wallpaper and calming apps settled down on both cost and rework once I locked the framing in the first generation and confined Omni Flash conversational editing to color and mood tweaks. Thinking about the image-side cost alongside Nano Banana 2 Lite cost design makes it clearer where to spend the order-of-magnitude difference between stills and video.

Editing video by conversation genuinely lowers the barrier to production. Just don't overtrust "say it and it changes" — confirm mechanically whether it landed, and move the instructions that miss over to the design side. That plain sorting was the shortest path to putting a preview-stage model to real indie work. I hope it helps your own implementation, and thank you for reading.