Updated November 2026: Gemini now defaults to low media resolution (about 100 tokens per second of video), Gemini agentic video mode (September 2026), current Gemini API prices, and a new section on uniform sampling vs scene detection.
Why This Matters
Every video-understanding feature your product team is scoping in 2026 — "summarise this meeting", "answer questions about this lecture", "flag the moment the forklift entered the restricted zone", "describe what the camera saw overnight" — runs on a video VLM, and the single biggest driver of its cost and quality is a decision most specs never mention: how the video becomes tokens. Get it wrong and a feature that should cost a fraction of a cent per video costs ten cents, or misses the one frame that mattered, or runs out of memory on a long recording. This lesson is for the product manager, founder, or operations lead who needs to sit in an architecture review and understand why the engineers keep arguing about "frames per second" and "token budgets". It builds directly on the shared-embedding-space idea from the CLIP primer; if "embedding" and "token" are new words, read that first.
The One Thing To Understand — A Video VLM Never Sees Your Video
Start with the mental model that fixes everything else. When you hand a two-hour recording to a video AI model, the model does not press play and watch it the way you would. It cannot. The model only understands one kind of input: a long list of small numbered chunks called tokens — in plain language, a token is the smallest unit of information the model reads, roughly four characters of text, or one small patch of an image. Text becomes tokens. Images become tokens. Video, which is just images in sequence, also becomes tokens. The model reads the tokens and nothing but the tokens.
This means a pipeline sits between your video file and the model, and that pipeline makes two decisions that the model has no say in. First, it samples frames: out of the thousands of frames in your video, it picks some to keep and throws the rest away. Second, it tokenises each kept frame: it turns that still picture into a fixed number of tokens. Everything about cost, speed, and accuracy traces back to these two numbers — how many frames, and how many tokens per frame.
Here is the analogy to hold onto. Imagine you hire an expert to review two hours of security footage, but you can only show them a contact sheet — a printed page of thumbnails. You decide how many thumbnails go on the page (frame sampling) and how big each thumbnail is (tokens per frame). A page of twelve tiny thumbnails is cheap to print and quick to scan, but your expert will miss the licence plate. A page of six hundred large thumbnails captures everything, but it is expensive and takes a long time to look through. The model is the expert; the contact sheet is the only thing it ever sees. The rest of this article is about how to build the right contact sheet.
Figure 1. The model never sees your video — only a sampled, tokenised contact sheet. The pipeline that builds it decides cost, speed, and accuracy.
Frame Sampling — Picking Which Moments The Model Gets To See
The first decision is frame sampling: choosing which frames survive the trip to the model. Almost every video VLM in 2026 samples at a fixed rate measured in frames per second (fps) — how many frames it keeps from each second of video. The default for most systems is 1 fps, meaning one frame survives per second and the other twenty-three to fifty-nine are discarded.
Why throw away that much? Because consecutive frames are nearly identical. In one second of a lecture, thirty frames show the same speaker at the same slide; keeping all thirty wastes the budget and teaches the model nothing new. This near-duplication has a name — temporal redundancy — and it is the reason sampling works at all. The trick is that redundancy is uneven: a static lecture has enormous redundancy, while a fast sports clip or a forklift turning a corner has very little. A single sampling rate cannot be right for both.
Google's Gemini models make the default explicit and documented. Per Google's Gemini API video-understanding guide (last updated October 2026), when you upload a video through the Files API it is stored and sampled at 1 frame per second, and you can override this with a custom fps value — lower for static content like lectures, higher for fast action. That single sentence is the whole frame-sampling story for a closed model: you pick an fps, the platform keeps that many frames, and your bill and your accuracy both follow from the choice. The full menu of closed frontier models and how their video handling differs is the subject of the closed-frontier lesson.
The pitfall sampling creates is the one teams discover too late. If the event you care about lasts less than the gap between sampled frames, the model may never see it. At 1 fps, a licence plate visible for half a second as a car passes can fall entirely between two sampled frames — the model is shown the empty road before and the empty road after, and confidently reports it saw no car. Engineers call this the "needle in a haystack" problem, and it is why "just lower the fps to save money" is dangerous advice without knowing how long the important events last.
Tokens Per Frame — How Expensive Each Picture Is
The second decision is how many tokens each surviving frame costs. This is set by the model's image tokeniser and, increasingly, by a resolution setting you control. The numbers are concrete and worth memorising for at least one model, because they anchor every cost estimate you will ever make.
Take Google's Gemini, the best-documented case. Per the Gemini API video-understanding guide (October 2026), each sampled frame is tokenised at 66 tokens per frame at low media resolution or 258 tokens per frame at any higher setting. Audio adds 32 tokens per second. Google puts the total at about 100 tokens per second of video at the default low resolution, or about 300 tokens per second at high resolution. Low is now the API default; earlier versions of the same guide treated 258 tokens a frame as the default, so cost estimates written before mid-2026 often assume the high setting without saying so. High resolution exists for a reason: Google's guide says it helps the model read fine text and pick out small details.
Now do the arithmetic out loud, because the cost of video understanding is nothing more than this multiplication. Suppose you send a 10-minute clip to Gemini at the default 1 fps and high media resolution. Ten minutes is 600 seconds, so the pipeline keeps 600 frames:
600 frames × 258 tokens/frame = 154,800 visual tokens
600 seconds × 32 tokens/second = 19,200 audio tokens
----------------------
total ≈ 174,000 input tokens
That ~174,000 tokens is what you are billed for as input. At Gemini 2.5 Flash's list price of $0.30 per million input tokens (unchanged on Google's pricing page in November 2026, and the same rate as the newer Gemini 3.5 Flash-Lite), the cost of feeding that ten-minute video is:
174,000 tokens ÷ 1,000,000 × $0.30 ≈ $0.052
About five cents to let a model watch and answer questions about a ten-minute video at high resolution. At the default low resolution (66 tokens a frame) the same clip is 58,800 tokens, under two cents. Model choice moves the bill as much as resolution does: Gemini 3.8 Flash lists at $0.75 per million input tokens through 31 December 2026 and $1.50 from 1 January 2027, so the high-resolution clip costs about 13 cents now and about 26 cents next year. That is the entire economics of the feature in two multiplications, and it is why "low or high resolution?" and "which model tier?" are budget decisions, not details.
Figure 2. The whole cost of video understanding is two multiplications: frames × tokens-per-frame, plus audio. Resolution and fps are the two dials. Gemini's default is now low resolution (green); high resolution (blue) costs about three times more.
The Context Window — The Hard Ceiling Everything Hits
Tokens are not just a cost; they are a hard limit. Every model has a context window — the maximum number of tokens it can hold in mind at once, input plus output. Once your sampled, tokenised video exceeds it, you physically cannot send more, no matter your budget.
This is where the two numbers collide with reality. Models with a 1-million-token context window — the large frontier models of 2026 — can hold, per Google's own statement, about three hours of video at the default low resolution or about one hour at high resolution. Walk the math and it lines up: one hour is 3,600 seconds, and at ~300 tokens/second that is ~1,080,000 tokens, right at the ceiling; at the default ~100 tokens/second the same window stretches to roughly three hours.
This single fact reshapes how you think about long video. A two-hour film simply will not fit at high resolution in a one-million-token window, and a four-hour recording will not fit even at the default. You have exactly three options, and every long-video product picks among them: drop the resolution (cheaper per frame, fits more, sees less detail), drop the frame rate (fewer frames, fits more, risks missing fast events), or stop trying to fit the whole thing at once and switch to a streaming approach — the second half of this article. There is no fourth option that gives you full resolution, full frame rate, and unlimited length. The context window is the wall, and architecture is how you live within it.
How Open Models Squeeze Frames — The Token-Compression Race
Closed models like Gemini hide the tokeniser behind an API. Open models — the ones you can download and run yourself — expose it, and the cleverest engineering of 2026 lives in how they shrink the token cost of each frame. Understanding the trick demystifies why open video models keep getting cheaper without getting worse.
Alibaba's Qwen2.5-VL, an open vision-language model released in 3-billion, 7-billion, and 72-billion-parameter sizes, shows the standard moves. Its vision encoder reads a frame as a grid of small patches — the same patch-grid idea explained in the Vision Transformer primer — then merges each 2×2 block of patches into a single token before the language model sees them, a four-to-one reduction up front. On top of that it uses dynamic frame-rate sampling and a position-encoding scheme (the model's internal sense of when each frame happened, which Qwen calls absolute time encoding via mRoPE) so it can handle videos sampled at different speeds and still pin events to real timestamps. The combined effect, per the Qwen team, is that the model caps a long video at a fixed token budget: in their setup, a video of up to 768 sampled frames is compressed so that every two frames share 64 tokens, for a maximum of 24,576 video tokens — a whole long video squeezed into a budget a frontier model spends on ninety seconds of raw frames.
Qwen2.5-VL's successor, Qwen3-VL (technical report, November 2025), keeps the same idea and adds two things that matter for video: a native 256K-token context for interleaved text, images and video, and explicit text timestamps in place of the older positional time encoding, so answers point to the right moment more reliably. It ships in dense 2B, 4B, 8B and 32B sizes and two mixture-of-experts variants (30B-A3B and 235B-A22B).
The open field pushes this further. Researchers at OpenGVLab report that InternVL3.5 turns each image tile into 1,024 raw visual tokens, then uses a step called pixel shuffle to compress them to 256 tokens — and a "Flash" variant compresses to just 64 tokens per tile, a sixteen-to-one reduction. The pattern across all of these is identical: spend tokens where detail matters, compress hard where it does not, and the model barely notices. For a product team the lesson is not the mechanism but the consequence — the token cost of open video models is dropping fast, which is exactly why "we can't afford to run a VLM on every camera" is a 2024 answer that may already be wrong in 2026.
Figure 3. Open models compress frames before the language model sees them — merging patches and pixel-shuffle cut tokens per frame by 4× to 16×, so whole long videos fit a fixed budget.
The Two Patterns — Frame Sampling Vs Token Streaming
Now the heart of the article. There are two fundamentally different ways to feed video to a model, and almost every product is built on one or the other. The choice is not a detail; it determines whether your feature can run live, how long a video it can handle, and what it costs.
Frame sampling — also called offline or batch processing — is everything described so far. You take a complete video file, sample frames from it, tokenise them all, and send the whole batch to the model in one request. The model sees the entire (sampled) video at once and can reason across it freely: it can compare the first minute to the last, answer "how many times did the speaker mention pricing", and jump to any timestamp. This is the right pattern when the video already exists and you can wait for an answer — a recorded meeting, an uploaded lecture, an overnight surveillance review. Its limits are the ones we have covered: the whole thing must fit in the context window, and you pay for every token up front.
Token streaming — also called online or real-time processing — is the opposite shape. Instead of one giant batch, frames arrive continuously, are tokenised one or a few at a time, and are fed to the model as a flowing stream. Crucially, the model does not keep every token forever; it maintains a rolling memory of recent frames and lets older ones fade, the way you remember the last few minutes of a conversation clearly and earlier minutes only in summary. This is the only pattern that works on video with no end — a live camera, an ongoing call, a feed that runs for days — because there is no "whole file" to fit in a context window. The trade is that the model cannot freely look back hours; it knows the recent past in detail and the distant past only through whatever summary it kept.
The academic and production work here is moving fast. VideoLLM-online (CVPR 2024) was an early streaming design that ran at 5–10 frames per second on a single consumer GPU and could proactively speak up mid-stream — narrating a change as it happened rather than waiting to be asked. More recent systems like Dispider (2025) split the job into three always-on parts — a light module that constantly watches, a second that decides when to respond, and a third that composes the answer — so the model can react at the right moment without freezing the stream. StreamingVLM (2025) targets stable understanding of, in its framing, effectively infinite video streams. In June 2026 a team behind Streaming Harness described a plug-in layer for existing VLMs that decides once per second whether to respond and reports 12 hours of context retention; treat those as the authors' own claims until independent results appear. In production APIs the limits are tighter. Google's Live API, the streaming side of Gemini, accepts video at 1 frame per second, holds a 128,000-token session context, and caps audio-plus-video sessions at 2 minutes (Firebase AI Logic limits page, October 2026). That is plenty for a live assistant that looks at what the camera sees right now and nowhere near a full-shift camera monitor. The names will change; the shape will not. If a feature has to respond while the video is still playing, it is a streaming feature, and frame-sampling architectures cannot do it.
Figure 4. Two architectures. Frame sampling sends a whole video at once and reasons across all of it; token streaming feeds frames continuously and remembers only the recent past — the only option for endless live video.
A Worked Comparison — The Same Feature, Both Ways
Make it concrete with one feature built two ways: "alert a security operator when someone enters a restricted zone."
Built with frame sampling, this is an overnight job. Every morning the system takes the previous night's eight-hour recording, samples it at 1 fps (28,800 frames), and — because that blows past any single context window — chops it into chunks, sends each chunk to the model, and stitches the answers. It produces a tidy report: "Entry detected at 02:14 and 03:48." It is cheap per camera and simple to build. It is also useless for stopping an intruder, because the answer arrives eight hours late.
Built with token streaming, the same feature watches the live feed. Frames flow in at a few per second, the model holds a rolling memory of the last minute or two, and the instant a person crosses the line it fires an alert — sub-second, while it matters. It costs more (the model runs continuously, not once a day) and is harder to build (you need the streaming infrastructure from the real-time AI pipeline lessons). But it is the only version that does the actual job.
Neither is "better". They are answers to different questions. The table below is the decision rule.
| Question | Frame sampling (offline) | Token streaming (online) |
|---|---|---|
| When does the answer arrive? | After the whole video is processed | While the video is still playing |
| Maximum video length | Limited by the context window (≈1–3 hrs for a 1M model) | Effectively unlimited |
| Can it reason across the whole video? | Yes — compares any moment to any other | Only across the recent past it still remembers |
| Typical cost shape | Pay once per video, up front | Pay continuously while the stream runs |
| Best for | Recorded meetings, uploaded lectures, archive review | Live cameras, ongoing calls, real-time alerts |
| Build complexity | Lower — one request, or chunked requests | Higher — streaming pipeline, memory management |
Where Frame Sampling Goes Wrong — And How 2026 Fixes It
The quiet weakness of frame sampling is that uniform sampling assumes every second matters equally, and it rarely does. One frame per second is wasteful on a two-hour static lecture and reckless on a two-minute action clip. Worse, on long, uncurated footage — surveillance, instructional recordings — the one moment that answers the user's question may be a single frame the uniform sampler happened to skip.
The 2026 response is adaptive, query-aware sampling: instead of grabbing one frame per second blindly, the pipeline looks at what the user asked and spends its frame budget where the answer is likely to be. Recent research makes the gains concrete. "Key clip selection" methods that grab short, relevant segments instead of isolated uniform frames have reported accuracy improvements of up to roughly 8–10 percentage points over uniform sampling on long-video benchmarks. Other 2026 systems learn a sampling policy — a small companion model that decides which frames to pull — and some report finding the right keyframes while sampling barely more than 1% of the video. The mechanism varies; the direction is consistent. By 2026 the question "how do we sample frames?" is shifting from "pick an fps" to "let a smaller model pick the frames that matter", and the savings are large enough that it is worth asking your engineers which approach a long-video feature uses.
The idea has now reached a commercial API. On 1 September 2026 Google introduced agentic video understanding in Gemini: you set processing to "agentic" and the model reads the transcript first, then loads only the segments it needs, at the frame rate it needs. Google reports up to 88% fewer tokens, up to 66% lower cost and up to 7% higher accuracy on standard video benchmarks, at normal token prices. The October 2026 docs list it for Gemini 3.8 Flash, 3.6 Flash and 3.5 Flash-Lite among others, with two caveats. It can take longer on long videos because the model makes several passes, and the manual fps and clipping controls work only in the default static mode. For recorded video where the question is known up front, agentic mode is the first thing to benchmark against plain 1 fps sampling.
The benchmark that tracks this progress is Video-MME, a 900-video evaluation spanning short, medium, and long clips. The leaderboard is a useful sanity check on vendor claims. As of November 2026 the top general scores on the llm-stats aggregator sit in the high 80s: ByteDance's Seed 2.1 Pro at 89.2% and Alibaba's Qwen3.7-Plus at 88.0%, all self-reported and unverified. The hardest "long video, no subtitles" slice is lower and thinly reported; the one entry there is GPT-4.1 at 72.0%. Long video is still the unsolved part, and any vendor claiming a solved long-video problem deserves scrutiny.
Uniform Sampling Vs Scene Detection — Which Costs Less?
Scene detection usually costs less on edited or mostly static video, and uniform sampling is safer on continuous footage. Uniform sampling keeps a frame every fixed interval (1 fps by default in Gemini), so tokens grow in a straight line with duration whatever happens on screen. Scene detection runs a cheap pixel-difference check on the CPU before the model is called and keeps one or a few frames per shot. A one-hour lecture with forty slide changes then costs forty-odd frames instead of 3,600.
That gap is the redundancy problem in numbers. Consecutive frames of a static shot are near-duplicates, and every duplicate still costs the full per-frame token price (66 or 258 tokens in Gemini), so on talking-head or screen-share video most of a uniform 1 fps budget pays for the same picture again and again. Scene detection removes those duplicates before they become tokens.
It fails in one predictable place: long continuous shots where the important thing happens inside the shot. A fixed security camera never "cuts", so a cut detector may keep only a handful of frames from an eight-hour night and miss the person who walked through at 02:14. For that kind of footage use uniform or motion-triggered sampling, or query-aware selection such as Gemini's agentic mode. In practice we combine them: one frame per detected scene as the floor, uniform sampling inside any scene longer than a set limit, and denser sampling around motion or audio events.
A Common Pitfall — Confusing "Long Context" With "Watches Everything"
The mistake we see most often is reading "1-million-token context window, supports 1-hour video" and concluding the model watches the hour the way a person would. It does not. At 1 fps it sees one frame per second — it is blind to the other twenty-nine thirtieths of every second, and any event shorter than a second can vanish between samples. "Supports one hour" means "one hour of frames fits in memory", not "perceives every moment of one hour".
The practical rule follows directly. Before you pick a model or a context size, ask one question about your actual content: how long is the shortest event the feature must catch? If the answer is "several seconds" — a person entering a room, a slide changing — 1 fps is fine and a long-context offline model is the cheap, simple choice. If the answer is "a fraction of a second" — a fast hand gesture, a licence plate on a passing car, a ball crossing a line — then 1 fps will miss it, and you need a higher frame rate (which shrinks the maximum video length that fits) or a targeted approach that samples densely only around the moment of interest. Matching the frame rate to the shortest event that matters is the single most important video-VLM decision, and it is the one most specs forget to make.
Free download: Video VLM Frame-Budget Decision SheetOne printable page: the token-cost arithmetic, the context-window limits, the frame-sampling vs token-streaming decision, and the pre-flight checklist ending with the ‘shortest event that matters’ question.Where Fora Soft Fits In
We build these pipelines into real video products, and the frame-sampling-versus-streaming choice shows up in every vertical we work in. In video surveillance, where our computer vision for video surveillance work sits, the live-alert features are streaming by necessity, while the "search last month's footage" features are offline and cost-optimised with adaptive sampling. In e-learning and OTT platforms, lecture summarisation and chapter generation are offline jobs where low resolution and a low frame rate cut the bill without hurting quality on slow-moving content. In video conferencing and telemedicine, live meeting assistants are streaming systems that hold a rolling memory of the call. Across all of them the engineering judgement is the same one this article teaches: match the frame rate to the shortest event that matters, match the architecture to whether the answer is needed live or later, and pick the lightest token budget that still clears the accuracy bar. Our AI video agent development team builds the live, streaming side of these systems, and our AI integration projects cover the offline summarisation and search jobs on recorded footage.
The book
AI for Video: A Complete Guide to Intelligence in Video Products: From Models and Inference to Computer Vision, Speech, Search, and Generative Video
This lesson gives you the two numbers behind every video VLM bill; volume 6 of the Fora Soft Video Engineering Handbook works through the models that consume them — vision transformers and patch tokenisers, open and closed vision-language models, frame selection for search and summarisation, and how to pick a model for a given video. Volume 7 takes the streaming side into production: real-time budgets, serving, and cost per stream-hour. Written by Nikolay Sapunov, CEO at Fora Soft.
Not sure whether your video AI feature should sample frames or stream them?
Tell us how long your videos run, how fast the events you care about happen and whether the answer must arrive live. We will size the frame rate, resolution and token budget, estimate the bill per video or per stream-hour, and pick offline, streaming or both. 250+ video products shipped since 2005.
See our case studies
Case study
Mindbox
AI video management system with both patterns side by side: live anomaly alerts on camera feeds and Smart Forensic Search across hours of recorded footage. 50+ deployments since 2020.
Case study
Meetric
AI sales video platform that records meetings, analyses them after the call and turns each one into a structured report, automating 80–100% of CRM data entry. Integrates with Google Meet, Teams and Zoom.
Case study
VALT
Recording platform for police interviews, medical training and child advocacy, where long recorded sessions are searched and reviewed after the fact. 770+ U.S. organizations, 50,000+ users.
What to read next
Foundations
CLIP and contrastive vision-language: the primer
The embedding and token ideas this lesson builds on, explained from scratch.
Models
Open-frontier VLMs: LLaVA, Qwen-VL, LLaVA-NeXT
The open models behind the token-compression tricks covered here, in depth.
Search
Multimodal RAG over a video archive
How to search hours of video when even a 1M-token context window is not enough.
Economics
The real cost of AI in video products
This lesson’s token arithmetic extended to full products, with 2026 API prices.
References
- "Video understanding." Google Gemini API documentation, ai.google.dev, last updated 2026-10-13 (accessed 2026-11-03). Primary source for the 1 fps default sampling rate, custom-fps override, 66 tokens/frame at low (default) and 258 tokens/frame at higher media resolution, 32 tokens/second audio, ~100 / ~300 tokens-per-second totals, the "1M context = ~3 hours default (low) / ~1 hour high" statement, and the agentic processing mode, its supported models and its static-only fps/clipping controls.
- "Introducing agentic video understanding with Gemini." Google blog, 1 September 2026 (accessed 2026-11-03). Source for the agentic mode launch date and the up-to-88% token, up-to-66% cost and up-to-7% accuracy figures.
- "Gemini Developer API pricing." ai.google.dev (accessed 2026-11-03). Source for Gemini 2.5 Flash and Gemini 3.5 Flash-Lite at $0.30 per million input tokens and Gemini 3.8 Flash at $0.75 through 31 December 2026 and $1.50 from 1 January 2027. Prices change and must be re-verified each quarter.
- "Live API limits and specs." Firebase AI Logic documentation, last updated 2026-10-27 (accessed 2026-11-03). Source for 1 fps video input, the 128,000-token session context and the 2-minute audio-plus-video session cap.
- Qwen Team. "Qwen2.5-VL." qwenlm.github.io blog, 26 January 2025, and the Qwen2.5-VL Technical Report (arXiv:2502.13923), February 2025 (accessed 2026-05-31). — Primary source for dynamic-FPS training, absolute time encoding via mRoPE, the window-attention vision encoder, 2×2 patch merging, and the open 3B/7B/72B sizes.
- QwenLM/Qwen3-VL repository discussion (GitHub issue on video experimental details) and Qwen3-VL Technical Report (arXiv:2511.21631), 2025 (accessed 2026-11-03). Source for the 256K native context, textual timestamp alignment and the 2B to 235B-A22B model lineup, and for the "768 frames → every two frames compressed to 64 tokens → 24,576-token cap" video-token budget.
- Wang, W., Chen, Z., et al. "InternVL3.5: Advancing Open-Source Multimodal Models in Versatility, Reasoning, and Efficiency." OpenGVLab, arXiv:2508.18265, 2025 (accessed 2026-05-31). — Source for the 1,024 → 256 pixel-shuffle compression and the 64-token "Flash" variant.
- Chen, J., et al. "VideoLLM-online: Online Video Large Language Model for Streaming Video." CVPR 2024, arXiv:2406.11816 (accessed 2026-05-31). — Source for the early streaming-VLM design, 5–10 fps on a consumer GPU, and proactive mid-stream response.
- Qian, R., et al. "Dispider: Enabling Video LLMs with Active Real-Time Interaction via Disentangled Perception, Decision, and Reaction." arXiv:2501.03218, 2025; and "StreamingVLM: Real-Time Understanding for Infinite Video Streams." arXiv:2510.09608, 2025 (accessed 2026-05-31). — Sources for the disentangled streaming architecture and infinite-stream framing.
- Fu, C., et al. "Video-MME: The First-Ever Comprehensive Evaluation Benchmark of Multi-modal LLMs in Video Analysis." CVPR 2025; and the Video-MME and Video-MME (long, no subtitles) leaderboards on llm-stats.com (accessed 2026-11-03). Source for the 900-video benchmark composition and the November 2026 self-reported scores (Seed 2.1 Pro 89.2%, Qwen3.7-Plus 88.0%; GPT-4.1 72.0% on long, no subtitles).
- "Harnessing Streaming Video in the Wild." arXiv:2606.08615, June 2026 (accessed 2026-11-03). Source for the Streaming Harness plug-in, per-second response decisions and the claimed 12-hour context retention.
- Zhang, G., et al. "From Frames to Clips: Efficient Key Clip Selection for Long-Form Video Understanding." arXiv:2510.02262, 2025; with related adaptive-sampling work (VideoBrain, arXiv:2602.04094, 2026; Generative Frame Sampler, arXiv:2503.09146, 2025) (accessed 2026-05-31). — Sources for the up-to-~8–10-point accuracy gains of key-clip/adaptive sampling over uniform sampling and the "≈1% of frames" keyframe-search figure.
