Agentic Video Understanding in Production: 97% Fewer Tokens at Mosaic

Benchmarks in press releases are usually "up to" numbers on a vendor's own evaluation. The September 17, 2026 write-up from Google for Developers is more useful than that, because it reports what three companies got on their own production workloads, and the three numbers came from three genuinely different architectures.

Mosaic cut median token usage 97%. Ponder Studio hit a 0.967 F1 score. Revyl improved accuracy 65%. None of those is the same kind of win, and the differences are the interesting part.

We covered how agentic video understanding actually works when Google launched it on September 1. This post is about what it buys once it is wired into something real.

TL;DR

Why the baseline was so bad

Standard video processing ingests frames at a fixed rate, typically 1 frame per second. That design has two failure modes at once, which is unusual and is why the gains here are so large.

It overpays on sparse footage. A three-hour recording of a mostly static screen costs the same per minute as three hours of dense action. You pay for 10,800 frames to find the four that matter.

It underpays on dense footage. Sampling at 1FPS means anything that happens between samples does not exist. A dropped frame, a 200ms UI stutter, a fast gesture: all invisible.

So the fixed-rate approach is simultaneously too expensive and not accurate enough, which is exactly the shape of problem where letting the model decide what to look at wins on both axes instead of trading one for the other. Our earlier piece on whether LLMs can actually watch video covers why this constraint existed for so long.

Mosaic: index first, then look twice

Mosaic's video agent, Motion, handles raw multi-hour production footage, which is the worst case for fixed-rate sampling.

Rather than flooding the prompt with every frame, Mosaic built an adaptive routing layer. The agent uses agentic video understanding to build an index of the footage, set targeted review windows, and then pull only high-density frames from the windows where edit constraints actually require verification.

Three distinct stages, and the ordering is the whole trick:

1. Index cheaply. Establish what is where across the full runtime, at low resolution and low cost.
2. Route. Decide which windows the current edit constraint depends on.
3. Verify expensively, but narrowly. Pull high-density frames only inside those windows.

The result: median token usage down 97%, and nearly double the ability to handle complex edits compared to static processing.

Note that second number, because it is the one that breaks the usual framing. This was not a cost-versus-quality trade. Capability roughly doubled while cost fell by a factor of thirty. That happens when the old bottleneck was context dilution rather than model capability: flooding a prompt with 10,000 mostly irrelevant frames makes the model worse at the task, not just more expensive. Removing the noise improves the answer.

This is the same principle behind context caching and token discipline in agent harnesses: what you leave out of context is a design decision with accuracy consequences, not just a billing one.

Ponder Studio: sometimes the loop is the problem

Ponder Studio's task is narrower: given raw B-roll, find the best stable camera shots by evaluating cinematic motion.

The interesting choice is what they did not build. Instead of a complex perception loop, Ponder uses a single agentic call. Result: a 0.967 F1 score, with token costs down roughly 72%.

An F1 of 0.967 on a subjective-sounding task like "is this a good, stable shot" is high. And it came from removing machinery rather than adding it.

The lesson generalises past video. Engineers reach for iterative perception loops because the task feels like it needs multiple passes. But a loop is only worth its complexity when each iteration has information the previous one lacked. If the model can evaluate the whole clip in one pass and the judgement is bounded, the loop is adding latency, cost, and failure modes in exchange for nothing. Ponder tested that assumption and found the simpler architecture won on both accuracy and cost.

Revyl: catching what 1FPS cannot see

Revyl works on mobile cloud development, and its problem is the accuracy half of the baseline failure rather than the cost half.

Static screenshot testing typically samples at 1FPS. Dropped frames and UI stutters routinely happen faster than that, so they never appear in the test evidence at all. The test passes and the bug ships.

Revyl wired agentic video understanding directly into their assertion loop. Gemini scans animations more closely when it matters, which catches quick bugs that fixed sampling misses. Reported improvement: 65% better accuracy.

Placing it in the assertion loop rather than in a preprocessing step is the design detail worth copying. The assertion already knows what property is being checked, so the model gets a specific question ("did this transition drop frames") rather than an open-ended one ("describe this video"). Specific questions are cheaper and more accurate, which is the same reason narrow prompts outperform broad ones in coding agents.

The pattern across all three

Strip the domains away and the same architecture appears three times:

Get cheap structure first, then spend selectively. Mosaic indexes before it verifies. Ponder evaluates once at the right altitude instead of looping. Revyl asks a targeted question at the moment the answer is needed.

None of them simply swapped a model and collected a discount. Each one restructured when the expensive operation happens. That is the transferable lesson, and it applies to any modality where input volume dwarfs the relevant signal: long documents, large codebases, log streams, call recordings.

The corollary is uncomfortable for a lot of existing pipelines: if your video, document, or log processing pays a fixed cost per unit of input regardless of relevance, you probably have a 10x to 30x inefficiency sitting in production, and it is likely costing you accuracy too.

How to get started

Agentic video understanding is available today for video uploads and YouTube videos. It is supported by Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash, and 3.5 Flash-Lite, via the Gemini API in Google AI Studio and the Gemini Enterprise Agent Platform.

Worth noting: at the September 1 launch the supported list was 3.7 Flash, 3.6 Flash and 3.5 Flash-Lite. Gemini 3.8 Flash has been added since, so if you evaluated this feature two weeks ago you were testing on older models than are available now.

A sensible evaluation order:

1. Measure your current baseline properly. Tokens per video-minute and accuracy on a labelled set. Without both, you cannot tell a real win from a cheaper wrong answer.
2. Start with the cost half. Token reduction is easy to verify and hard to argue with.
3. Then check whether accuracy moved. If the Mosaic pattern holds for your workload, it should go up, not merely hold.
4. Only add routing complexity if measurement justifies it. Ponder's result is the reminder that the simplest structure sometimes wins outright.

Honest limitations

• These are vendor-published customer numbers. They come from Google's own developer blog, reporting results from partners given early access. They are specific and attributed, which is better than most, but they are not independent benchmarks and the evaluation sets are not public.
• All three had early access to unreleased models. Your results on generally available models may differ.
• Short clips benefit least. The savings come from skipping irrelevant footage. A 20-second video of continuous relevant action has little to skip, and the routing overhead may not pay for itself.
• "Nearly doubled" is not a defined metric. Mosaic's complex-edit capability improvement is real but unquantified in a way you can reproduce.
• F1 without the test set is limited. 0.967 is excellent, but B-roll stability is a judgement call, and the score depends entirely on how the ground truth was labelled.
• Cost is not only tokens. Agentic routing adds round trips. If your workload is latency-sensitive, measure wall-clock time, not just token counts.

Related on explainx.ai

• Gemini agentic video understanding: how it works — the mechanism, API parameter, and a worked example
• Can LLMs actually watch video? — why fixed-rate sampling was the constraint
• Gemini 3.8 Flash: launch and coding benchmarks — the newest model in the supported list
• Gemini 3.7 Flash in Antigravity and AI Studio — the model most of this work was built on
• Context caching and agent harness token costs — the same spend-selectively principle for text
• Loop engineering for coding agents — why narrow questions beat broad ones
• Gemini 3.6 Flash and 3.5 Flash-Lite launch — where the Flash line started this cycle

Official: Google's agentic video announcement and the developer guide in AI Studio.

Results reported here are from Google for Developers' September 17, 2026 write-up of three early-access partners, and have not been independently reproduced. Model availability reflects that date; the supported model list has already changed once since the September 1 launch, so check the developer guide before relying on a specific model.