Gemini Agentic 비디오가 항상 저렴하지는 않습니다: 24 실행 벤치마크

A controlled Gemini 3.7 Flash benchmark shows why agentic video is excellent for long-form search—but can cost more than static processing on short clips.

If I only need one number from a long video, why should an AI model sample the entire timeline before answering?

Google launched Agentic Video Understanding on September 1. Instead of processing video at a fixed sampling rate, Gemini can decide whether to inspect the transcript, audio, or selected frame ranges based on the question.

Google reports up to 88% fewer tokens, 66% lower cost, and 7% higher quality on long-form video. Those numbers are compelling, but they do not answer the question I had while building with it:

Is agentic processing cheaper for every video and every query?

I ran the same videos and prompts through both agentic and static processing. Long-form workloads were dramatically cheaper with agentic processing. Short visual workloads were not.

Current model support

The public Gemini guide currently lists these models as supporting Agentic Video Understanding:

• Gemini 3.8 Flash
• Gemini 3.7 Flash
• Gemini 3.6 Flash
• Gemini 3.5 Flash-Lite

Gemini 3.8 Flash is the newest option and is worth evaluating for new applications. To keep this comparison controlled, however, every result in this article was produced with Gemini 3.7 Flash. Mixing model changes into an agentic-versus-static comparison would make the numbers harder to interpret.

Enabling agentic processing

I used the Interactions API. The processing mode belongs on the video input:

response = client.interactions.create(
    model="gemini-3.7-flash",  # Benchmark model; new apps can evaluate 3.8 Flash
    input=[
        {
            "type": "video",
            "uri": video.uri,
            "mime_type": video.mime_type,
            "processing": "agentic",  # Use "static" for the control
        },
        {"type": "text", "text": prompt},
    ],
)

Enter fullscreen mode Exit fullscreen mode

The current public documentation says video processing defaults to static, but I set both modes explicitly. I also checked the response steps rather than assuming a successful response meant agentic processing had run.

All 12 agentic calls contained both processing_call and processing_result. None of the 12 static calls did.

Benchmark design

I used two videos that I own:

• a 2-minute-21-second UI screen recording;
• a 10-minute-21-second conference talk.

I tested four workloads:

1. Find a clear UI state change in the short video.
2. Find the shortest, hardest-to-notice visual change in the short video.
3. Summarize the long video in five timestamped points.
4. Find one specific detail that appears only once in the long video.

Each workload ran three times in each mode: 4 workloads × 2 modes × 3 repetitions = 24 API calls.

The table uses medians for API total_tokens and client-observed end-to-end latency. A three-run sample is still small, but it is more honest than selecting one convenient request.

Results

Workload Agentic total tokens Static total tokens Token difference Agentic / Static latency Short video: UI detail 12,101 10,055 +20% 21.8s / 10.0s Short video: brief motion 34,038 10,559 +222% 32.9s / 10.1s Long video: summary 1,394 57,610 −97.6% 10.5s / 14.1s Long video: one-off detail 4,481 57,778 −92.2% 14.5s / 12.0s

The long-form result is clear. For the 10-minute talk, agentic processing used about 2.4% of the static token count for summarization and about 7.8% for one-off detail retrieval.

The short-video result went in the opposite direction. Agentic processing used 20% more tokens for a general UI change and 222% more for a brief visual event. The brief-motion query also took more than three times as long.

There was substantial variance as well. The three agentic runs for the brief-motion query ranged from 12,300 to 56,487 total tokens. One run would have told a very different story depending on which sample I happened to receive.

Did the extra short-video cost buy better detail?

Yes—but whether it was worth paying for depends on the product requirement.

For the brief-motion query, agentic processing found a Loading agents, please wait... screen that appeared for roughly 0.2 seconds. I checked the original frames at 0.75 and 0.9 seconds: the loading message really does disappear into the full interface almost immediately.

Static processing found a different event that remained visible for about two seconds.

So the extra agentic work was not simply wasted. It found a more fleeting event. But if the product only needs one obvious UI transition, the static answer is already useful, faster, and more stable.

For the long video, both modes returned usable timestamped answers. I spot-checked a resource identifier cited around 8:20 against the original frame and confirmed it was present. Agentic processing avoided loading the full video context while still finding relevant material.

A practical selection rule

Requirement Starting point Long-form summaries, lectures, or meeting analysis Agentic Finding a statement, number, or moment in a long video Agentic Short clips where latency matters most Static Sub-second motion, tiny text, or frame-level inspection Test both; pay the agentic cost only when the added precision matters A global default for a production system Route by both video length and query type

I do not treat agentic processing as a universally better replacement for static processing. I treat it as a workload-routing decision.

When a question can be answered by inspecting a transcript and a few targeted windows, agentic processing can remove most of the video tokens. When the task requires broad visual coverage or repeated high-resolution inspection, navigation itself can cost more than simply sampling the clip.

What I would ship

For an application handling mixed video workloads, I would not expose one global processing-mode switch and call it done. I would route requests using at least these signals:

• video duration;
• whether the query is transcript-heavy or visually precise;
• latency requirements;
• whether a first static answer is sufficient;
• observed token variance for the workload.

I would also log the effective processing steps and token categories. If the application cannot verify that agentic processing actually ran, it cannot explain either quality or cost.

Agentic Video Understanding gives developers a useful new control, not permission to stop measuring. If you have lectures, meetings, demos, or long interviews, start with one real question, run both modes three times, and choose based on the workload rather than the feature name.

Official documentation: Gemini API Video Understanding

Google launch post: Introducing agentic video understanding with Gemini