Paper deep dive
Enhancing Long-Video VLM Embeddings with Query-Aware Streaming Latent Reasoning
Haozhe Chi, Song Jin, Yang Jin, Yadong Mu
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Long-video embedding requires capturing sparse query-relevant evidence under a limited visual-token budget. Uniform sampling can miss brief events in videos spanning minutes or hours, whereas encoding more frames in a single context increases memory and computation. We introduce \textbf{Query-Aware Streaming Latent Reasoning} (QASLR), a post-training framework that accumulates evidence across clips while keeping the embedding size fixed. QASLR selects a bounded set of frames, restores their temporal order, and processes them clip by clip with a vision-language backbone. A compact set of persistent think tokens cross-attends to each clip's features, while an embed token reads out a normalized representation after every update. This design integrates evidence across multiple backbone calls without requiring all selected frames to share a single context. Training combines final contrastive learning, step-wise contrastive supervision, and final-embedding self-distillation. Intermediate supervision trains partial-video readouts for retrieval, while self-distillation regularizes them toward the final representation. Query-aware selection produces query-conditioned representations for candidate-set scoring and reranking, whereas query-independent selection enables reusable corpus indexing. Under the full training recipe, HourVideo retrieval Hit@1 increases from 54.2 to 70.7 and from 57.4 to 72.8 for 2B and 8B Qwen3-VL-Embedding backbones, respectively. Gains extend to the evaluated moment-retrieval and video-QA tasks, and the streaming head transfers to a second Qwen-family embedding backbone. These results support streaming latent aggregation as an effective approach to integrating long-video evidence into fixed-dimensional representations.
Tags
Links
- Source: https://arxiv.org/abs/2610.04864v1
- Canonical: https://arxiv.org/abs/2610.04864v1
Trouble viewing inline? Open PDF directly →
Full Text
76,918 characters extracted from source content.
Expand or collapse full text
Enhancing Long-Video VLM Embeddings with Query-Aware Streaming Latent Reasoning Haozhe Chi Affiliation: Peking University Song Jin Affiliation: Renmin University of China Yang Jin Affiliation: Peking University Yadong Mu Affiliation: Peking University Abstract Long-video embedding requires capturing sparse query-relevant evidence under a limited visual-token budget. Uniform sampling can miss brief events in videos spanning minutes or hours, whereas encoding more frames in a single context increases memory and computation. We introduce Query-Aware Streaming Latent Reasoning (QASLR), a post-training framework that accumulates evidence across clips while keeping the embedding size fixed. QASLR selects a bounded set of frames, restores their temporal order, and processes them clip by clip with a vision-language backbone. A compact set of persistent think tokens cross-attends to each clip’s features, while an embed token reads out a normalized representation after every update. This design integrates evidence across multiple backbone calls without requiring all selected frames to share a single context. Training combines final contrastive learning, step-wise contrastive supervision, and final-embedding self-distillation. Intermediate supervision trains partial-video readouts for retrieval, while self-distillation regularizes them toward the final representation. Query-aware selection produces query-conditioned representations for candidate-set scoring and reranking, whereas query-independent selection enables reusable corpus indexing. Under the full training recipe, HourVideo retrieval Hit@1 increases from 54.2 to 70.7 and from 57.4 to 72.8 for 2B and 8B Qwen3-VL-Embedding backbones, respectively. Gains extend to the evaluated moment-retrieval and video-QA tasks, and the streaming head transfers to a second Qwen-family embedding backbone. These results support streaming latent aggregation as an effective approach to integrating long-video evidence into fixed-dimensional representations. 1 Introduction Multimodal embedding models provide a common representation interface for retrieving, organizing, and comparing text, images, and videos (Radford et al., 2021; Jia et al., 2021; Girdhar et al., 2023; Meng et al., 2026). Their fixed-dimensional outputs are attractive for large collections because candidate representations can be indexed once and searched efficiently (Johnson et al., 2021; Karpukhin et al., 2020). Extending this interface to long videos is difficult, however, because the visual input grows with duration whereas the model’s visual-token budget remains bounded (Zhang et al., 2025a; Shen et al., 2025). A video may span tens of minutes, while the evidence that determines its relevance to a query may occupy only a few seconds (Chandrasegaran et al., 2024; Wu et al., 2024). Consequently, the quality of a long-video embedding depends not only on semantic alignment, but also on whether the model observes the relevant evidence and retains it while processing the rest of the sequence. Existing pipelines usually address the input constraint by sampling a fixed number of frames. Uniform sampling provides broad temporal coverage at low cost, but can miss brief relevant events when a fixed frame budget is spread across a longer video (Yu et al., 2023; Tang et al., 2025). Query-aware selection concentrates a limited budget on semantically relevant frames (Wang et al., 2025b; Tang et al., 2025), but it does not by itself solve the representation problem. Selected frames may be temporally fragmented, and encoding all of them in one context couples the frame budget to the backbone’s memory cost. Moreover, query-aware selection changes the retrieval setting: because the selected frames depend on the query, the resulting video representation cannot generally be reused as a single query-independent corpus embedding. A practical system must therefore distinguish query-independent indexing from query-conditioned candidate scoring, as in embedding-and-reranking pipelines (Li et al., 2026). A second issue concerns how selected evidence is aggregated. Video-retrieval encoders have explored joint spatiotemporal encoding and pooling of frame-level representations (Bain et al., 2021; Xu et al., 2021; Luo et al., 2022), while memory-augmented video models explicitly retain information across observations (Song et al., 2024; He et al., 2024). These developments motivate studying how a compact streaming state can be trained to produce useful retrieval embeddings throughout a video. This issue is particularly important when relevant observations are distributed across time or when the number of selected frames still exceeds the context that can be processed economically in one forward pass. We therefore study long-video evidence accumulation through a bounded latent state, building on latent bottlenecks and recurrent memory architectures (Jaegle et al., 2021; Bulatov et al., 2022; Hutchins et al., 2022). We propose Query-Aware Streaming Latent Reasoning (QASLR), a post-training framework for long-video embeddings. As shown in Figure 1, QASLR processes selected frames as chronologically ordered clips, using learnable think tokens to accumulate clip-level evidence in a persistent latent memory. An embed token reads out a fixed-dimensional representation after each step. Query-independent frame selection enables reusable video indexing, whereas query-aware selection produces query-conditioned representations for a bounded candidate set, such as candidates returned by a first-stage retriever. Training combines a final contrastive loss with step-wise supervision (Lee et al., 2015) and self-distillation toward the final embedding (Zhang et al., 2019), aligning both intermediate and complete representations with their targets. Following MMEB and MMEB-V2 (Jiang et al., 2025; Meng et al., 2026), a unified query–positive interface supports retrieval, moment retrieval, classification, and multiple-choice video question answering (QA). Interleaved sub-batching groups compatible input formats during mixed-task training and is evaluated separately from streaming aggregation. The full QASLR training recipe improves both 2B and 8B Qwen3-VL-Embedding backbones (Li et al., 2026), increasing HourVideo retrieval Hit@1 from 54.2 to 70.7 and from 57.4 to 72.8, respectively, relative to the original checkpoints. Gains extend to the evaluated moment-retrieval and video-QA tasks, while experiments on RzenEmbed (Jian et al., 2025) demonstrate applicability to a second Qwen-family embedding backbone. Our contributions are threefold: • We introduce QASLR, a streaming framework that decouples temporal coverage from representation size for long-video embedding. A persistent latent memory incrementally integrates temporally ordered clips and emits a fixed-dimensional embedding without placing all selected frames in one backbone context. • We design a streaming post-training objective that combines final contrastive learning, step-wise contrastive supervision, and final-embedding self-distillation. This objective directly supervises intermediate representations through the same query–positive interface used across retrieval, classification, and video QA. • We evaluate QASLR on nine long-video tasks using 2B and 8B Qwen3-VL-Embedding models and demonstrate within-family transfer to RzenEmbed 7B. The full QASLR recipe improves every reported task over the original checkpoints. Figure 1: From one-shot video encoding to streaming evidence accumulation. The upper-left pathway illustrates a one-shot baseline that pools representations from sparsely sampled frames into a single video embedding. The lower-left pathway shows QASLR processing selected frames as ordered clips and producing embeddings throughout the sequence. The right-hand panels summarize example training signals and the intended capabilities of persistent memory, intermediate supervision, optional early exit, and parameter-efficient post-training. 2 Related Work 2.1 Multimodal Embeddings and Long-Video Processing Contrastive learning supports shared image–text and multimodal representations (Radford et al., 2021; Jia et al., 2021; Zhai et al., 2023; Girdhar et al., 2023), with temporal encoders and aggregation extending this approach to video (Bain et al., 2021; Xu et al., 2021; Luo et al., 2022). Instruction-guided retrieval and VLM-based embeddings unify diverse retrieval tasks (Wei et al., 2024; Jiang et al., 2024; Jiang et al., 2025; Zhang et al., 2025b), with recent models supporting video and document inputs (Meng et al., 2026; Jian et al., 2025; Li et al., 2026). Long-video benchmarks highlight challenges in temporal coverage and reasoning (Fu et al., 2025; Zhou et al., 2025; Wang et al., 2025a). Existing approaches extend context (Zhang et al., 2025a), compress visual tokens (Shen et al., 2025), aggregate clip descriptions (Zhang et al., 2024a), select query-relevant frames (Yu et al., 2023; Wang et al., 2025b; Tang et al., 2025), or allocate frame-wise resolution (Jin et al., 2026). Temporally grounded datasets provide localized language–video supervision (Krishna et al., 2017; Gao et al., 2017; Lei et al., 2021). Complementing input selection and compression, QASLR accumulates selected clip evidence into a fixed-dimensional embedding. 2.2 Streaming Latent Reasoning and Adaptive Computation Latent-query architectures compress inputs through cross-attention (Jaegle et al., 2021; Jaegle et al., 2022; Alayrac et al., 2022; Li et al., 2023), while recurrence and memory tokens carry information across sequence blocks (Dai et al., 2019; Bulatov et al., 2022; Hutchins et al., 2022). Video models similarly retain historical information (Song et al., 2024; He et al., 2024) and support streaming interaction (Chen et al., 2024; Zhang et al., 2024b). Related approaches introduce computation before prediction through pause tokens (Goyal et al., 2024), continuous hidden states (Hao et al., 2025), or explicit reasoning traces for embeddings (Cui et al., 2026). Building on these ideas, QASLR updates persistent latent memory across clips and contrastively supervises intermediate embedding readouts. Early-exit methods adapt computation using intermediate predictions (Xin et al., 2020; Elbayad et al., 2020; Schuster et al., 2022). QASLR’s optional exit instead controls the number of observed clips. Figure 2: QASLR architecture, training objectives, and optional early-exit inference. Selected frames are ordered and partitioned into clips. The illustrated 128-frame configuration contains eight clips of 16 frames each. Per-clip backbone features are compressed into evidence banks that update persistent think-token memory through cross-attention and feed-forward refinement. An embed token reads the memory to produce an L2-normalized embedding after each update. Training combines final contrastive learning, step-wise supervision, and final-embedding self-distillation across the supported video tasks. The optional stop gate terminates processing when its stopping criterion is met. 3 Method 3.1 Overview and Retrieval Settings Figure 2 summarizes QASLR. A fixed set of think tokens accumulates clip evidence, and an embed token reads the latent state after each update. Streaming refers to aggregation over preselected clips, not necessarily online frame selection from an unseen video. Following unified multimodal embedding frameworks (Wei et al., 2024; Jiang et al., 2025; Meng et al., 2026), we formulate all tasks as query–positive pairs (Ai,Bi)(A_i,B_i). The query AiA_i may contain text, an image–text input, or a video–question input, while BiB_i may be a video, temporal window, class label, or answer. Non-video and short-video inputs retain the original embedding pathway. Long videos use the proposed streaming pathway. QASLR supports two retrieval settings, distinguishing reusable dense representations (Karpukhin et al., 2020) from pair-conditioned scoring (Li et al., 2026). In the indexable setting, frame selection is query-independent, and each candidate video produces one reusable embedding jv_j. In the query-conditioned setting, frame selection and video encoding depend on query AiA_i, producing ijv_ij. The similarity score is sij=i⊤j/τ,indexable,i⊤ij/τ,query-conditioned,s_ij= casesq_i v_j/τ,&indexable,\\[2.0pt] q_i v_ij/τ,&query-conditioned, cases (1) where iq_i is the normalized query embedding and τ is the contrastive temperature. Query-conditioned scoring is restricted to a bounded candidate set, such as the output of a first-stage retriever. Every candidate for a given query is selected and encoded using the same conditioning procedure. 3.2 Streaming Video Encoding Query-guided frame selection has been explored for video QA (Yu et al., 2023; Tang et al., 2025). QASLR treats selection as an input stage: for a long video V and optional conditioning input c, the selector returns an ordered sequence of at most KmaxK_ indices: ℐ(V,c)=(k1,…,kKV),k1<⋯<kKV,KV≤Kmax.I(V,c)=(k_1,…,k_K_V), k_1<·s<k_K_V, K_V≤ K_ . (2) The selected frames are restored to chronological order and divided into clips: X(V,c)=[C1,…,CT],T=⌈KVL⌉,X(V,c)=[C_1,…,C_T], T= K_VL , (3) where L is the number of frames per clip. We use Kmax=128K_ =128, with L=16L=16 at full budget and fewer frames per clip for shorter inputs. Padding in the final clip is excluded by the attention mask. Ground-truth labels and temporal boundaries are not provided to the frame selector during evaluation. At step t, the vision-language backbone FθF_θ, instantiated from Qwen3-VL-Embedding (Li et al., 2026) built on Qwen3-VL (Bai et al., 2025), encodes the current clip together with the task instruction and optional conditioning input: Ut=Fθ(Ct,c)∈ℝB×St×D,U_t=F_θ(C_t,c) ^B× S_t× D, (4) where B, StS_t, and D denote the batch size, valid sequence length, and backbone hidden dimension. To bound the input size of the streaming head, the valid hidden states are compressed into at most M evidence tokens: Et=Compress(Ut)∈ℝB×M×D.E_t=Compress(U_t) ^B× M× D. (5) The compression operator uses cosine similarity to compress valid hidden states after masking. We use M=256M=256 and N=32N=32 think tokens by default. Evidence banks with fewer than M states are padded and masked in cross-attention. Clips may share a backbone forward pass, but their evidence banks and latent states remain independent. 3.3 Streaming Latent Memory and Embedding Readout Motivated by compact latent bottlenecks (Jaegle et al., 2021) and recurrent memory tokens (Bulatov et al., 2022), QASLR maintains N learnable think tokens as a persistent latent memory: H0∈ℝB×N×D.H_0 ^B× N× D. (6) The memory is initialized once for each video and is not reset between clips. At streaming step t, the previous memory attends to the current clip evidence using multi-head attention (Vaswani et al., 2017) and layer normalization (Ba et al., 2016): H~t=LN[Ht−1+MHA(LN(Ht−1),LN(Et),LN(Et))], H_t=LN [H_t-1+MHA (LN(H_t-1),LN(E_t),LN(E_t) ) ], (7) Ht=LN[H~t+FFN(H~t)].H_t=LN [ H_t+FFN( H_t) ]. (8) The recurrent update allows the model to integrate new visual evidence while retaining information from earlier clips. Because the number of think tokens remains fixed, the size of the persistent state does not grow with video duration. After each update, a learnable embed token e reads the current memory through query-based attention pooling, as in Perceiver IO (Jaegle et al., 2022): rt=MHA(e,Ht,Ht),t=Wrt‖Wrt‖2,r_t=MHA(e,H_t,H_t), _t= Wr_t\|Wr_t\|_2, (9) where W projects the readout into the shared d-dimensional embedding space. The streaming pathway returns Z(V,c)=(1,…,T),Z(V,c)=(z_1,…,z_T), (10) and uses Tz_T as the final video representation. Intermediate embeddings expose the representation after each observed clip and are used by the auxiliary training objectives below. 3.4 Training Objective For a batch of B query–positive pairs, let ia_i denote the final query-side embedding and ijb_ij the representation of candidate BjB_j when scored against AiA_i. In the indexable setting, ij=jb_ij=b_j. In the query-conditioned setting, each candidate is encoded under AiA_i. The final loss uses an InfoNCE-style contrastive objective (van den Oord et al., 2018; Radford et al., 2021): ℒfinal=CE(S~,y),sij=i⊤ijτ,yi=i.L_final=CE( S,y), s_ij= a_i b_ijτ, y_i=i. (11) Query-independent embeddings can be gathered across workers to enlarge the negative pool (Chen et al., 2020). Query-conditioned scores instead require each candidate to be encoded under the current query. Embeddings conditioned on another query are not interchangeable. Valid co-positives from the same video are masked from the denominator, while the paired target remains the sole positive (Khosla et al., 2020; Jian et al., 2025). Here, S~ S equals S with excluded co-positive logits set to −∞-∞. Following deep supervision (Lee et al., 2015), we also train intermediate embeddings. Let ℬtB_t contain pairs with valid step-t readouts on all streaming sides. Non-streaming embeddings are reused. The step-wise loss is ℒstep=∑t|ℬt|CE(S~(t),y(t))∑t|ℬt|,sij(t)=(i(t))⊤ij(t)τ.L_step= _t|B_t|CE( S^(t),y^(t)) _t|B_t|, s_ij^(t)= (a_i^(t) ) b_ij^(t)τ. (12) At each step, invalid pairs and padded readouts are excluded, targets are reindexed within ℬtB_t, and the same co-positive mask is applied. Text-to-video retrieval reuses text embeddings. Video QA reuses answer embeddings. To regularize the streaming trajectory, we adapt knowledge distillation (Hinton et al., 2015) and self-distillation (Zhang et al., 2019) by using the final embedding as a stop-gradient teacher: ℒdistill=1Z∑i∈∑t=1Ti−1[1−(i(t))⊤sg(i(Ti))],L_distill= 1Z _i _t=1^T_i-1 [1- (z_i^(t) ) sg (z_i^(T_i) ) ], (13) where S contains the streamed inputs, TiT_i is the number of valid steps, and Z=∑i∈(Ti−1)Z= _i (T_i-1). When Z=0Z=0, we define ℒdistill=0L_distill=0. Unlike the moving-average target network in BYOL (Grill et al., 2020), the teacher here is the detached final-step embedding from the same forward trajectory. The complete objective is ℒ=ℒfinal+λstepℒstep+λdistillℒdistill.L=L_final+ _stepL_step+ _distillL_distill. (14) Mixed-task training combines retrieval, moment retrieval, classification, and video QA through the same query–positive interface. Interleaved sub-batching groups examples with compatible task and input formats. Their losses are weighted by the corresponding sub-batch sizes, and gradients are accumulated before one optimizer update. Only the streaming head is trainable in the QASLR experiments. The backbone is frozen. The appendix describes data processing, computational complexity, and the optional early-exit mechanism. 4 Experiments 4.1 Experimental Setup Tasks and metrics. We evaluated nine long-video embedding tasks spanning classification, video retrieval, moment retrieval, and multiple-choice QA. These comprised HourVideo (Chandrasegaran et al., 2024) classification, retrieval, and moment retrieval, LVBench (Wang et al., 2025a) retrieval and QA, LongVideoBench (Wu et al., 2024) moment retrieval, MovieChat QA (Song et al., 2024), EgoSchema (Mangalam et al., 2023), and TimeScope (Zohar et al., 2025). We report Hit@1/Hit@5 for classification and retrieval, except LongVideoBench moment retrieval (Hit@1 only), and accuracy for QA. All reported gains are in percentage points. Models and training. We compared original Qwen3-VL-Embedding (Li et al., 2026) checkpoints, single-round post-training, and QASLR at 2B and 8B scales. Both post-training methods used the same training data. QASLR selected at most 128 frames, using 16-frame clips at full budget and shorter clips for fewer frames. Training combined final contrastive learning, step-wise contrastive supervision, and final-embedding self-distillation. Only the streaming head was trainable in QASLR. The backbone remained frozen. Mixed-task data processing. All examples used a common query–positive format. Retrieval paired a query with a video or candidate moment, whereas QA paired a video–question input with its answer text. Selected frames were stored as indices and decoded from source videos on demand. Interleaved sub-batching grouped compatible task and input formats, with its effects examined in Section 4.4. Comparison protocol. The original checkpoints establish performance before long-video post-training. Single-round post-training uses the mixed-task data without recurrent latent aggregation. Table 1 evaluates the complete QASLR recipe rather than isolated architectural changes. Table 2 additionally compares both post-training methods with sub-batching, while Appendix A.5 clarifies their interpretation. Training and evaluation details are provided in Appendices A.2–A.4. Table 1: Long-video embedding performance on Qwen3-VL-Embedding backbones. The original checkpoints, single-round post-training (PT), and full QASLR recipe are compared at the 2B and 8B scales. CLS, Ret., and MRet. denote classification, video retrieval, and video moment retrieval, respectively. Retrieval-style entries report Hit@1/Hit@5, except LongVideoBench MRet., which reports Hit@1 only. Question-answering (QA) entries report accuracy. Avg. is the unweighted mean across the four QA tasks. All scores are percentages, with higher values indicating better performance. Bold numeric entries identify the best result for each metric within each backbone scale. Retrieval-style tasks Backbone Method HourVideo CLS HourVideo Ret. HourVideo MRet. LVBench Ret. LongVideoBench MRet. Qwen3-VL 2B Original 51.1 / 85.1 54.2 / 77.1 24.3 / 62.2 65.4 / 98.1 34.2 Single-round PT 52.4 / 86.3 55.0 / 76.7 25.2 / 63.0 66.6 / 98.0 35.1 QASLR 54.2 / 88.1 70.7 / 92.5 30.1 / 65.8 75.7 / 98.3 37.0 Qwen3-VL 8B Original 52.2 / 83.9 57.4 / 87.5 24.9 / 63.1 68.1 / 98.4 33.2 Single-round PT 53.0 / 84.3 57.8 / 88.4 25.6 / 63.8 69.2 / 98.1 34.5 QASLR 57.3 / 89.6 72.8 / 95.8 27.7 / 66.6 77.3 / 98.2 38.8 QA-style tasks Backbone Method MovieChat QA LVBench QA EgoSchema TimeScope Avg. Qwen3-VL 2B Original 54.1 41.1 59.8 38.0 48.3 Single-round PT 54.5 41.4 60.4 39.2 48.9 QASLR 55.2 42.3 63.5 41.3 50.6 Qwen3-VL 8B Original 55.7 38.9 70.2 80.0 61.2 Single-round PT 55.2 39.6 71.7 81.3 62.0 QASLR 60.3 44.7 74.5 85.6 66.3 Table 2: Effects of streaming aggregation and interleaved sub-batching. All configurations use query-aware selection. PT and QASLR are evaluated with or without sub-batching. Ret. and MRet. denote video retrieval and video moment retrieval. Retrieval entries report Hit@1/Hit@5, except LongVideoBench MRet., which reports Hit@1 only. Avg. H@1 averages Hit@1 across the three retrieval tasks. QA entries report accuracy. All scores are percentages, and bold numeric entries mark the best result within each backbone and metric. QASLR with sub-batching achieves the highest retrieval Hit@1, whereas the strongest QA configuration varies across tasks. Retrieval-style tasks Backbone Method HourVideo Ret. LVBench Ret. LongVideoBench MRet. Avg. H@1 Qwen3-VL 2B Original 54.2 / 77.1 65.4 / 98.1 34.2 51.3 Single-round PT 55.0 / 76.7 66.6 / 98.0 35.1 52.2 Single-round PT w/ sub-batching 66.1 / 84.2 67.5 / 98.2 36.7 56.8 QASLR w/o sub-batching 55.4 / 78.8 73.3 / 98.0 34.8 54.5 QASLR w/ sub-batching 70.7 / 92.5 75.7 / 98.3 37.0 61.1 Qwen3-VL 8B Original 57.4 / 87.5 68.1 / 98.4 33.2 52.9 Single-round PT 57.8 / 88.4 69.2 / 98.1 34.5 53.8 Single-round PT w/ sub-batching 67.3 / 93.5 75.8 / 98.0 36.7 59.9 QASLR w/o sub-batching 59.2 / 89.9 72.4 / 98.3 35.6 55.7 QASLR w/ sub-batching 72.8 / 95.8 77.3 / 98.2 38.8 63.0 QA-style tasks Backbone Method MovieChat LVBench EgoSchema TimeScope Qwen3-VL 2B Original 54.1 41.1 59.8 38.0 Single-round PT 54.5 41.4 60.4 39.2 Single-round PT w/ sub-batching 58.8 47.2 62.9 42.4 QASLR w/o sub-batching 47.0 36.8 60.7 38.8 QASLR w/ sub-batching 55.2 42.3 63.5 41.3 Qwen3-VL 8B Original 55.7 38.9 70.2 80.0 Single-round PT 55.2 39.6 71.7 81.3 Single-round PT w/ sub-batching 61.5 43.3 73.8 84.1 QASLR w/o sub-batching 53.2 41.7 72.2 80.5 QASLR w/ sub-batching 60.3 44.7 74.5 85.6 Figure 3: Within-family transfer of QASLR to RzenEmbed 7B. Grouped bars compare the original checkpoint, single-round post-training, and QASLR across seven tasks using the same RzenEmbed backbone. Classification (CLS), video retrieval (Ret.), and moment retrieval (MRet.) report Hit@1. Question-answering tasks report accuracy. All scores are percentages, and annotations above the QASLR bars give absolute improvements over the original checkpoint in percentage points. QASLR exceeds both baselines on every displayed task, with gains of 3.4–6.0 points over the original checkpoint. 4.2 Main Results on Qwen3-VL-Embedding In Table 1, QASLR achieved the highest Hit@1 on all five retrieval-style tasks at both scales. Mean Hit@1 increased from 45.8 to 53.5 at 2B and from 47.2 to 54.8 at 8B, compared with single-round averages of 46.9 and 48.0. The similar gains over the original checkpoints show that improvement was not limited to one model scale. Video retrieval and classification. The largest gains occurred on full-video retrieval. QASLR achieved 70.7/92.5 HourVideo Hit@1/Hit@5 at 2B and 72.8/95.8 at 8B, exceeding the original checkpoints by 16.5 and 15.4 Hit@1 points, respectively. Relative to single-round post-training, the corresponding Hit@1 gains were 15.7 and 15.0 points. HourVideo Hit@5 also improved by 15.4 and 8.3 points over the original checkpoints, showing gains in both top-one and top-five retrieval. On LVBench retrieval, Hit@1 improved by 10.3 and 9.2 points over the original checkpoints, while Hit@5 remained near 98. Thus, the LVBench gains primarily reflect better top-ranked ordering rather than expanded top-five coverage. HourVideo classification improved more moderately, from 51.1 to 54.2 at 2B and from 52.2 to 57.3 at 8B. Moment retrieval. HourVideo moment-retrieval Hit@1 increased from 24.3 to 30.1 at 2B and from 24.9 to 27.7 at 8B, with Hit@5 also improving at both scales. LongVideoBench Hit@1 rose from 34.2 to 37.0 and from 33.2 to 38.8, respectively. The larger HourVideo gain at 2B and larger LongVideoBench gain at 8B indicate task-dependent effects of model scale. Video question answering. QASLR improved all four QA tasks over both baselines in Table 1. Mean accuracy increased from 48.3 to 50.6 at 2B and from 61.2 to 66.3 at 8B relative to the original checkpoints. The 8B gains were 4.6 points on MovieChat, 5.8 on LVBench, 4.3 on EgoSchema, and 5.6 on TimeScope. Improvements at 2B ranged from 1.1 to 3.7 points. Single-round post-training achieved mean QA accuracies of 48.9 and 62.0, so the additional gains with QASLR were larger at 8B. These results concern the complete recipe. Comparison with sub-batched single-round training reveals a less uniform QA advantage, as discussed below. 4.3 Generalization to Another VLM Embedding Backbone Figure 3 compares the original RzenEmbed 7B checkpoint, single-round post-training, and QASLR. This Qwen2-VL-based backbone provides a test beyond Qwen3-VL-Embedding using the same training formulation. QASLR exceeded both baselines on all seven displayed tasks, with gains of 3.4–6.0 points over the original checkpoint. Improvements span classification, retrieval, moment retrieval, and QA, rather than a single task family. Relative to single-round post-training, QASLR raised EgoSchema accuracy from 61.1 to 66.3 and LongVideoBench moment-retrieval Hit@1 from 32.3 to 35.7. Because both backbones belong to the Qwen family, this experiment supports within-family transfer, not generalization across unrelated architectures. 4.4 Effect of Interleaved Sub-Batching Table 2 shows that the sub-batching configuration, including a larger effective batch, improved QASLR’s mean retrieval Hit@1 from 54.5 to 61.1 at 2B and from 55.7 to 63.0 at 8B. HourVideo retrieval gains were 15.3 and 13.6 points, respectively. LVBench retrieval improved by 2.4 and 4.9 Hit@1 points, while LongVideoBench moment retrieval improved by 2.2 and 3.2 points. At 2B, MovieChat and LVBench QA fell below the original checkpoint without sub-batching, reaching 47.0 and 36.8. Sub-batching recovered them to 55.2 and 42.3. At 8B, QA gains ranged from 2.3 points on EgoSchema to 7.1 on MovieChat. Sub-batching therefore benefited both retrieval and QA within the QASLR configuration. However, sub-batching also improved single-round post-training: mean retrieval Hit@1 increased from 52.2 to 56.8 at 2B and from 53.8 to 59.9 at 8B. With sub-batching, QASLR retained higher Hit@1 on all three retrieval tasks at both scales. Mean scores were 61.1 versus 56.8 at 2B and 63.0 versus 59.9 at 8B. At the task level, HourVideo Hit@1 gains over this baseline were 4.6 points at 2B and 5.5 at 8B. The corresponding margins were 8.2 and 1.5 points on LVBench, and 0.3 and 2.1 on LongVideoBench, showing task- and scale-dependent differences. QA results were mixed: single-round post-training scored higher on three of four tasks at 2B and on MovieChat at 8B. These comparisons show substantial gains from the batching configuration, while QASLR’s advantage over the sub-batched baseline is consistent for retrieval but task-dependent for QA. 5 Conclusion We introduced QASLR, a post-training framework that represents long videos through a fixed-size latent memory updated over temporally ordered clips. The full training recipe improved retrieval, moment retrieval, classification, and multiple-choice QA relative to the original checkpoints at both the 2B and 8B scales. The streaming head also transferred to a second Qwen-family embedding model. QASLR stores frame indices rather than duplicated images and preserves the downstream embedding interface. Its query-aware path produces query-conditioned representations and is therefore intended for bounded candidate sets or second-stage reranking. Query-independent selection remains necessary when each video must be indexed once and reused across queries. Sub-batching benefits both single-round and streaming models, although improvements in QA remain task-dependent. Future work could assess generalization beyond Qwen-family backbones and evaluate whether adaptive stopping can reduce inference cost while preserving task performance. AI use statement Generative AI tools were used solely to improve the clarity and readability of the manuscript. They were not used to formulate scientific claims, design experiments, generate results, or interpret findings. All AI-assisted edits were reviewed by the authors, who take full responsibility for the manuscript. Ethics Statement This work does not involve human participants, personally identifiable information, or private data. We recognize that the proposed method may inherit biases and limitations from its training data and underlying models. Potential misuse and unintended deployment risks should therefore be carefully considered in real-world applications. All authors have reviewed the ethical implications of this work and take responsibility for its content. Reproducibility Statement We provide detailed descriptions of the proposed method, model configuration, training procedure, datasets, evaluation protocols, and hyperparameters in the main paper and appendices. We report the computational resources and random seeds used in our experiments where applicable. The implementation details necessary to reproduce the main results are provided in the paper and appendices. References Alayrac et al. (2022) J. Alayrac, J. Donahue, P. Luc, et al. Flamingo: a visual language model for few-shot learning. In Advances in Neural Information Processing Systems, Vol. 35, p. 23716–23736. Cited by: §2.2. Ba et al. (2016) J. L. Ba, J. R. Kiros, and G. E. Hinton Layer normalization. Note: arXiv preprint arXiv:1607.06450 Cited by: §3.3. Bai et al. (2025) S. Bai, Y. Cai, R. Chen, et al. Qwen3-VL technical report. Note: arXiv preprint arXiv:2511.21631 Cited by: §3.2. Bain et al. (2021) M. Bain, A. Nagrani, G. Varol, and A. Zisserman Frozen in Time: a joint video and image encoder for end-to-end retrieval. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 1728–1738. Cited by: §1, §2.1. Bulatov et al. (2022) A. Bulatov, Y. Kuratov, and M. S. Burtsev Recurrent memory transformer. In Advances in Neural Information Processing Systems, Vol. 35, p. 11079–11091. Cited by: §1, §2.2, §3.3. Chandrasegaran et al. (2024) K. Chandrasegaran, A. Gupta, L. M. Hadzic, T. Kota, J. He, C. Eyzaguirre, Z. Durante, M. Li, J. Wu, and L. Fei-Fei HourVideo: 1-hour video-language understanding. In Advances in Neural Information Processing Systems, Vol. 37, p. 53168–53197. Cited by: §1, §4.1. Chen et al. (2024) J. Chen, Z. Lv, S. Wu, K. Q. Lin, C. Song, D. Gao, J. Liu, Z. Gao, D. Mao, and M. Z. Shou VideoLLM-online: online video large language model for streaming video. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 18407–18418. Cited by: §2.2. Chen et al. (2020) T. Chen, S. Kornblith, M. Norouzi, and G. Hinton A simple framework for contrastive learning of visual representations. In Proceedings of the 37th International Conference on Machine Learning, Vol. 119, p. 1597–1607. Cited by: §3.4. Cui et al. (2026) X. Cui, J. Cheng, H. Chen, et al. Think then embed: generative context improves multimodal embedding. In International Conference on Learning Representations, p. 2690–2709. Cited by: §2.2. Dai et al. (2019) Z. Dai, Z. Yang, Y. Yang, J. Carbonell, Q. V. Le, and R. Salakhutdinov Transformer-XL: attentive language models beyond a fixed-length context. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, p. 2978–2988. Cited by: §2.2. Elbayad et al. (2020) M. Elbayad, J. Gu, E. Grave, and M. Auli Depth-adaptive transformer. In 8th International Conference on Learning Representations, External Links: Link Cited by: §2.2. Fu et al. (2025) C. Fu, Y. Dai, Y. Luo, et al. Video-MME: the first-ever comprehensive evaluation benchmark of multi-modal LLMs in video analysis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 24108–24118. Cited by: §2.1. Gao et al. (2017) J. Gao, C. Sun, Z. Yang, and R. Nevatia TALL: temporal activity localization via language query. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), p. 5267–5275. Cited by: §2.1. Girdhar et al. (2023) R. Girdhar, A. El-Nouby, Z. Liu, M. Singh, K. V. Alwala, A. Joulin, and I. Misra ImageBind: one embedding space to bind them all. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 15180–15190. Cited by: §1, §2.1. Goyal et al. (2024) S. Goyal, Z. Ji, A. S. Rawat, A. K. Menon, S. Kumar, and V. Nagarajan Think before you speak: training language models with pause tokens. In International Conference on Learning Representations, p. 27896–27923. Cited by: §2.2. Grill et al. (2020) J. Grill, F. Strub, F. Altché, et al. Bootstrap your own latent - a new approach to self-supervised learning. In Advances in Neural Information Processing Systems, Vol. 33, p. 21271–21284. Cited by: §3.4. Hao et al. (2025) S. Hao, S. Sukhbaatar, D. Su, X. Li, Z. Hu, J. E. Weston, and Y. Tian Training large language models to reason in a continuous latent space. In Conference on Language Modeling, Cited by: §2.2. He et al. (2024) B. He, H. Li, Y. K. Jang, M. Jia, X. Cao, A. Shah, A. Shrivastava, and S. Lim MA-LMM: memory-augmented large multimodal model for long-term video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 13504–13514. Cited by: §1, §2.2. Hinton et al. (2015) G. Hinton, O. Vinyals, and J. Dean Distilling the knowledge in a neural network. Note: arXiv preprint arXiv:1503.02531 Cited by: §3.4. Hutchins et al. (2022) D. Hutchins, I. Schlag, Y. Wu, E. Dyer, and B. Neyshabur Block-recurrent transformers. In Advances in Neural Information Processing Systems, Vol. 35, p. 33248–33261. Cited by: §1, §2.2. Jaegle et al. (2022) A. Jaegle, S. Borgeaud, J. Alayrac, C. Doersch, C. Ionescu, D. Ding, S. Koppula, D. Zoran, A. Brock, E. Shelhamer, O. J. Hénaff, M. M. Botvinick, A. Zisserman, O. Vinyals, and J. Carreira Perceiver IO: a general architecture for structured inputs & outputs. In International Conference on Learning Representations, External Links: Link Cited by: §2.2, §3.3. Jaegle et al. (2021) A. Jaegle, F. Gimeno, A. Brock, O. Vinyals, A. Zisserman, and J. Carreira Perceiver: general perception with iterative attention. In Proceedings of the 38th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 139, p. 4651–4664. External Links: Link Cited by: §1, §2.2, §3.3. Jia et al. (2021) C. Jia, Y. Yang, Y. Xia, Y. Chen, Z. Parekh, H. Pham, Q. V. Le, Y. Sung, Z. Li, and T. Duerig Scaling up visual and vision-language representation learning with noisy text supervision. In Proceedings of the 38th International Conference on Machine Learning, Vol. 139, p. 4904–4916. Cited by: §1, §2.1. Jian et al. (2025) W. Jian, Y. Zhang, D. Liang, C. Xie, Y. He, D. Leng, and Y. Yin RzenEmbed: towards comprehensive multimodal retrieval. Note: arXiv preprint arXiv:2510.27350 Cited by: §1, §2.1, §3.4. Jiang et al. (2024) T. Jiang, M. Song, Z. Zhang, H. Huang, W. Deng, F. Sun, Q. Zhang, D. Wang, and F. Zhuang E5-V: universal embeddings with multimodal large language models. Note: arXiv preprint arXiv:2407.12580 Cited by: §2.1. Jiang et al. (2025) Z. Jiang, R. Meng, X. Yang, S. Yavuz, Y. Zhou, and W. Chen VLM2Vec: training vision-language models for massive multimodal embedding tasks. In International Conference on Learning Representations, p. 1255–1279. Cited by: §1, §2.1, §3.1. Jin et al. (2026) S. Jin, Z. Jiang, C. Shen, H. Liao, H. Chi, Z. Wang, K. Xu, and Y. Liu Allocate before you embed: adaptive visual input allocation for video embeddings. Note: arXiv preprint arXiv:2609.01778 Cited by: §2.1. Johnson et al. (2021) J. Johnson, M. Douze, and H. Jégou Billion-scale similarity search with GPUs. IEEE Transactions on Big Data 7 (3), p. 535–547. Note: First published online in 2019 External Links: Document Cited by: §1. Karpukhin et al. (2020) V. Karpukhin, B. Oguz, S. Min, P. Lewis, L. Wu, S. Edunov, D. Chen, and W. Yih Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), p. 6769–6781. Cited by: §1, §3.1. Khosla et al. (2020) P. Khosla, P. Teterwak, C. Wang, A. Sarna, Y. Tian, P. Isola, A. Maschinot, C. Liu, and D. Krishnan Supervised contrastive learning. In Advances in Neural Information Processing Systems, Vol. 33, p. 18661–18673. Cited by: §3.4. Krishna et al. (2017) R. Krishna, K. Hata, F. Ren, L. Fei-Fei, and J. C. Niebles Dense-captioning events in videos. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), p. 706–715. Cited by: §2.1. Lee et al. (2015) C. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu Deeply-supervised nets. In Proceedings of the Eighteenth International Conference on Artificial Intelligence and Statistics, Vol. 38, p. 562–570. Cited by: §1, §3.4. Lei et al. (2021) J. Lei, T. L. Berg, and M. Bansal Detecting moments and highlights in videos via natural language queries. In Advances in Neural Information Processing Systems, Vol. 34, p. 11846–11858. Cited by: §2.1. Li et al. (2023) J. Li, D. Li, S. Savarese, and S. Hoi BLIP-2: bootstrapping language-image pre-training with frozen image encoders and large language models. In Proceedings of the 40th International Conference on Machine Learning, Vol. 202, p. 19730–19742. Cited by: §2.2. Li et al. (2026) M. Li, Y. Zhang, D. Long, et al. Qwen3-VL-Embedding and Qwen3-VL-Reranker: a unified framework for state-of-the-art multimodal retrieval and ranking. Note: arXiv preprint arXiv:2601.04720 Cited by: §1, §1, §2.1, §3.1, §3.2, §4.1. Luo et al. (2022) H. Luo, L. Ji, M. Zhong, Y. Chen, W. Lei, N. Duan, and T. Li CLIP4Clip: an empirical study of CLIP for end to end video clip retrieval and captioning. Neurocomputing 508, p. 293–304. External Links: Document Cited by: §1, §2.1. Mangalam et al. (2023) K. Mangalam, R. Akshulakov, and J. Malik EgoSchema: a diagnostic benchmark for very long-form video language understanding. In Advances in Neural Information Processing Systems, Vol. 36, p. 46212–46244. Cited by: §4.1. Meng et al. (2026) R. Meng, Z. Jiang, Y. Liu, M. Su, X. Yang, Y. Fu, C. Qin, R. Thirukovalluru, X. Zhang, Z. Chen, R. Xu, C. Xiong, Y. Zhou, W. Chen, and S. Yavuz VLM2Vec-V2: advancing multimodal embedding for videos, images, and visual documents. Transactions on Machine Learning Research. External Links: Link Cited by: §1, §1, §2.1, §3.1. Radford et al. (2021) A. Radford, J. W. Kim, C. Hallacy, et al. Learning transferable visual models from natural language supervision. In Proceedings of the 38th International Conference on Machine Learning, Vol. 139, p. 8748–8763. Cited by: §1, §2.1, §3.4. Schuster et al. (2022) T. Schuster, A. Fisch, J. Gupta, M. Dehghani, D. Bahri, V. Q. Tran, Y. Tay, and D. Metzler Confident adaptive language modeling. In Advances in Neural Information Processing Systems, Vol. 35, p. 17456–17472. Cited by: §2.2. Shen et al. (2025) X. Shen, Y. Xiong, C. Zhao, et al. LongVU: spatiotemporal adaptive compression for long video-language understanding. In Proceedings of the 42nd International Conference on Machine Learning, Vol. 267, p. 54582–54599. Cited by: §1, §2.1. Song et al. (2024) E. Song, W. Chai, G. Wang, et al. MovieChat: from dense token to sparse memory for long video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 18221–18232. Cited by: §1, §2.2, §4.1. Tang et al. (2025) X. Tang, J. Qiu, L. Xie, Y. Tian, J. Jiao, and Q. Ye Adaptive keyframe sampling for long video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 29118–29128. Cited by: §1, §2.1, §3.2. van den Oord et al. (2018) A. van den Oord, Y. Li, and O. Vinyals Representation learning with contrastive predictive coding. Note: arXiv preprint arXiv:1807.03748 Cited by: §3.4. Vaswani et al. (2017) A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin Attention is all you need. In Advances in Neural Information Processing Systems, Vol. 30. External Links: Link Cited by: §3.3. Wang et al. (2025a) W. Wang, Z. He, W. Hong, et al. LVBench: an extreme long video understanding benchmark. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 22958–22967. Cited by: §2.1, §4.1. Wang et al. (2025b) Z. Wang, S. Yu, E. Stengel-Eskin, J. Yoon, F. Cheng, G. Bertasius, and M. Bansal VideoTree: adaptive tree-based video representation for LLM reasoning on long videos. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 3272–3283. Cited by: §1, §2.1. Wei et al. (2024) C. Wei, Y. Chen, H. Chen, H. Hu, G. Zhang, J. Fu, A. Ritter, and W. Chen UniIR: training and benchmarking universal multimodal information retrievers. In Computer Vision – ECCV 2024, Lecture Notes in Computer Science, Vol. 15145, p. 387–404. External Links: Document, Link Cited by: §2.1, §3.1. Wu et al. (2024) H. Wu, D. Li, B. Chen, and J. Li LongVideoBench: a benchmark for long-context interleaved video-language understanding. In Advances in Neural Information Processing Systems, Vol. 37, p. 28828–28857. Cited by: §1, §4.1. Xin et al. (2020) J. Xin, R. Tang, J. Lee, Y. Yu, and J. Lin DeeBERT: dynamic early exiting for accelerating BERT inference. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, p. 2246–2251. Cited by: §2.2. Xu et al. (2021) H. Xu, G. Ghosh, P. Huang, D. Okhonko, A. Aghajanyan, F. Metze, L. Zettlemoyer, and C. Feichtenhofer VideoCLIP: contrastive pre-training for zero-shot video-text understanding. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, p. 6787–6800. Cited by: §1, §2.1. Yu et al. (2023) S. Yu, J. Cho, P. Yadav, and M. Bansal Self-chained image-language model for video localization and question answering. In Advances in Neural Information Processing Systems, Vol. 36, p. 76749–76771. Cited by: §1, §2.1, §3.2. Zhai et al. (2023) X. Zhai, B. Mustafa, A. Kolesnikov, and L. Beyer Sigmoid loss for language image pre-training. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 11975–11986. Cited by: §2.1. Zhang et al. (2024a) C. Zhang, T. Lu, M. M. Islam, Z. Wang, S. Yu, M. Bansal, and G. Bertasius A simple LLM framework for long-range video question-answering. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, p. 21715–21737. Cited by: §2.1. Zhang et al. (2024b) H. Zhang, Y. Wang, Y. Tang, Y. Liu, J. Feng, J. Dai, and X. Jin Flash-VStream: memory-based real-time understanding for long video streams. Note: arXiv preprint arXiv:2406.08085 Cited by: §2.2. Zhang et al. (2019) L. Zhang, J. Song, A. Gao, J. Chen, C. Bao, and K. Ma Be your own teacher: improve the performance of convolutional neural networks via self distillation. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 3713–3722. External Links: Document, Link Cited by: §1, §3.4. Zhang et al. (2025a) P. Zhang, K. Zhang, B. Li, G. Zeng, J. Yang, Y. Zhang, Z. Wang, H. Tan, C. Li, and Z. Liu Long context transfer from language to vision. Transactions on Machine Learning Research. External Links: Link Cited by: §1, §2.1. Zhang et al. (2025b) X. Zhang, Y. Zhang, W. Xie, M. Li, Z. Dai, D. Long, P. Xie, M. Zhang, W. Li, and M. Zhang Bridging modalities: improving universal multimodal retrieval by multimodal large language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 9274–9285. Cited by: §2.1. Zhou et al. (2025) J. Zhou, Y. Shu, B. Zhao, et al. MLVU: benchmarking multi-task long video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 13691–13701. Cited by: §2.1. Zohar et al. (2025) O. Zohar, X. Wang, R. Li, A. Marafioti, M. Farré, M. Noyan, L. von Werra, S. Yeung-Levy, and T. Wolf Apollo2: exploring the long-video frontier of large multimodal models. Note: Official citation for the TimeScope benchmark External Links: Link Cited by: §4.1. Appendix A Appendix This appendix describes the training configuration, evaluation data, component comparisons, and theoretical properties of QASLR. A.1 Detailed Algorithm Table 3 summarizes the QASLR training pathway. Each example is represented through a query–positive interface, and selected frame indices are decoded on demand. Streaming memory is initialized once for each input and retained across its clips. Table 3: QASLR post-training procedure for unified query–positive pairs. Selected frame indices are decoded on demand and restored to chronological order before clip-wise backbone encoding. A bounded evidence bank updates the persistent think-token memory, which is initialized once per video and read out after every clip. The optimization combines final contrastive learning with the enabled auxiliary objectives. Interleaved sub-batching groups compatible task and input formats before parameter updates. The gate objective applies only when training the optional early-exit module; it is not required for fixed-length streaming inference. Input: training pairs (qi,pi)i=1P\(q_i,p_i)\_i=1^P, selected frame indices, VLM backbone FθF_θ, streaming head GϕG_φ, temperature τ, loss weights λstep,λdistill _step, _distill. 1. Sample a mini-batch of query-positive pairs. If interleaved sub-batching is enabled, group examples with similar task and input format into homogeneous sub-batches. 2. For each streaming video item, decode selected frame indices from the original video and restore chronological order. 3. Split selected frames into clips [C1,…,CT][C_1,…,C_T]. 4. For each clip CtC_t, encode Ut=Fθ(Ct,c)U_t=F_θ(C_t,c), where c is the permitted conditioning input, omitted for query-independent video encoding. 5. Compress valid hidden states into a fixed-size evidence bank EtE_t. 6. Initialize think-token memory H0H_0 and update it sequentially: Ht=Updateϕ(Ht−1,Et)H_t=Update_φ(H_t-1,E_t). 7. Read out step embeddings zt=Readoutϕ(Ht)z_t=Readout_φ(H_t). 8. Compute the masked final contrastive loss and enabled auxiliary embedding losses; train the optional gate separately after embedding training. 9. Update the streaming-head parameters while keeping the pretrained backbone frozen. State isolation and padding. Each video trajectory has an independent memory state. Packing clips into a backbone batch does not permit attention or memory sharing between different inputs. Padded evidence tokens and unavailable readouts are masked. Non-streaming inputs retain their original embedding pathway. Inference. Fixed-length inference returns the final valid readout. Optional early exit returns an intermediate readout when the stopping rule is satisfied. Early-exit use in local-clip QA is discussed separately in Section A.10. A.2 Implementation Details Backbone input and output. The image processor uses a pixel-area range of 4,096–1,310,720, with height and width aligned to multiples of 32. The output embedding dimensions are 2,048 for Qwen3-VL-Embedding 2B and 4,096 for Qwen3-VL-Embedding 8B. Streaming configuration. The main QASLR configuration selects at most 128 frames and uses 32 think tokens and at most 256 evidence tokens per clip. At the full frame budget, 16 frames per clip give eight streaming updates. For inputs with fewer selected frames, the number of frames per clip is reduced. Only valid frames and readouts contribute to attention and auxiliary losses. Compression uses cosine similarity between valid hidden-state representations to construct the evidence bank. Trainable modules. Only the streaming latent reasoning head is updated in QASLR, while pretrained backbone parameters remain frozen. The trainable parameter counts are approximately 200 million for the 2B configuration and 600 million for the 8B configuration. These counts refer to the trainable head rather than the total model size. Optimization. Post-training uses AdamW with a learning rate of 10−410^-4 and approximately three to five epochs, depending on the configuration. Training runs on NVIDIA H100 GPUs, with a per-GPU batch size of 4 or 8 and a global effective batch size of 256 or 512 across configurations. The step-wise contrastive and self-distillation weights are λstep=0.1 _step=0.1 and λdistill=0.01 _distill=0.01, respectively. The reported experimental results are averaged over three random seeds. Interleaved sub-batching. Compatible examples are grouped by task and input format. Negative candidates are shared across sub-batches and GPUs, and the effective batch size increases in the sub-batching configuration. The sub-batching configuration therefore changes both the effective optimization batch size and the negative pool. For query-conditioned scoring, shared candidates retain the query-conditioning requirement defined in the main objective. Frame storage. Selected frames are recorded as indices with optional timestamps and decoded from the original videos when needed. This avoids storing duplicated image copies for every query–video annotation. Frame indices and timestamps provide references to the original video without duplicating the selected images. A.3 Additional Experimental Details Post-training data. Post-training primarily uses LLaVA-Video-178K, supplemented with 10,000 ActivityNet videos. Benchmark annotations and task construction. QA annotations are taken from the corresponding original benchmark datasets. The four QA results in the main comparison are MovieChat, LVBench, EgoSchema, and TimeScope. Classification, video retrieval, and moment retrieval use sampled and filtered subsets of the source datasets. Their sizes vary by dataset and task, from tens to thousands of examples. GPT-4o assists annotation by constructing pairs of visual frames from video segments and textual questions. We will publicly release the complete evaluation sets for all reported tasks to support reproducibility and future research on long-video understanding. Candidate sets. These evaluations use bounded candidate sets. Video-retrieval questions generally have 4 or 8 candidates, and moment-retrieval questions generally have 8 or 16 candidate segments, depending on video length. Classification uses 4–8 categories, depending on the dataset. QA questions generally contain four answer options. Retrieval scores measure ranking within these task-specific candidate sets. The candidate-count distribution also affects Hit@5: with four candidates and a valid positive, top-five retrieval necessarily includes that positive. QA scoring. The video–question input is embedded on the query side, and the original answer options are embedded on the candidate side. The selected answer is the option with the highest embedding similarity. No additional QA prompt is introduced beyond this input construction. Metrics and averaging. Retrieval-style tasks report Hit@1/Hit@5 where available, and QA reports accuracy. LongVideoBench moment retrieval reports Hit@1. Results are averaged over three random seeds. Task averages include only the tasks specified in the relevant table and do not weight by the number of examples. A.4 Evaluation Modes and Query Conditioning Query-aware frame selection. We use Q-Frame for training-free frame selection conditioned on text. For a given retrieval query, the same query conditions selection and encoding for both positive and negative candidates. Ground-truth labels and annotated temporal boundaries are not provided to the selector during evaluation. The resulting video representation is query-conditioned and is intended for bounded candidate scoring. Indexing and two-stage scoring. Query-independent selection and encoding produce one reusable representation per video. Query-aware selection instead requires candidate processing after the query is available. Table 4 distinguishes these deployment modes. In its two-stage comparison, the single-round and QASLR methods use the same first-stage candidate lists, and first-stage misses remain in the denominator of final Hit@1. Table 2 uses query-aware selection throughout, whereas Table 4 additionally evaluates query-independent indexing. Table 4: Indexable and query-conditioned retrieval on HourVideo with Qwen3-VL-Embedding 2B. Uniform-selection methods produce one query-independent representation per video that can be reused across queries. SB denotes interleaved sub-batching; the uniform single-round row does not use SB. Two-stage methods apply query-aware selection and candidate scoring only to the top-M videos returned by a query-independent first stage. First-stage R@M measures positive-video recall before second-stage scoring, and Hit@1 measures final retrieval performance; both are percentages. First stage indicates that only the initial retrieval stage is pre-indexable, and a dash marks an inapplicable shortlist-recall entry. Latency is measured in seconds per query on NVIDIA H100 hardware with a warm cache. Mode Query-aware Pre-indexable First-stage R@M Hit@1 Latency (s) Uniform, single-round No Yes – 55.0 0.18 Uniform, QASLR + SB No Yes – 64.1 0.61 Two-stage, single-round + SB Yes First stage 95.8 66.1 1.26 Two-stage, QASLR + SB Yes First stage 95.8 70.7 1.72 First-stage recall and final accuracy. Let R denote shortlist size, to distinguish it from the evidence-bank size M. Let R(q)C_R(q) be the shortlist and (q)P(q) the valid positive set. First-stage recall measures whether R(q)∩(q)C_R(q) (q) is nonempty, while final Hit@1 measures whether the top-ranked candidate is positive. A first-stage miss contributes zero to the latter. Consequently, end-to-end Hit@1 cannot exceed first-stage recall. The reported values imply approximate top-one success rates conditional on a first-stage hit of 66.1/95.8=69.0%66.1/95.8=69.0\% and 70.7/95.8=73.8%70.7/95.8=73.8\%. Both conditional rates are calculated from the rounded values in Table 4. A.5 Attribution of the Main Gain Training configuration. All configurations in Table 2, including the original checkpoints, use query-aware frame selection. At 2B, single-round HourVideo Hit@1 increases from 55.0 to 66.1 with the sub-batching configuration. This configuration combines task-compatible grouping, cross-sub-batch and cross-GPU negatives, and a larger effective batch size. The comparison measures their combined contribution to post-training. Streaming contribution. Relative to the original checkpoints, the complete QASLR recipe improves HourVideo Hit@1 by 16.5 and 15.4 points at 2B and 8B. Against single-round training with sub-batching, the corresponding gains are 4.6 and 5.5 points. This comparison evaluates the streaming training configuration with sub-batching present in both methods. Task-dependent QA gains. At 2B, QASLR minus sub-batched single-round differences are −3.6-3.6, −4.9-4.9, +0.6+0.6, and −1.1-1.1 points on MovieChat, LVBench, EgoSchema, and TimeScope. At 8B, the corresponding differences are −1.2-1.2, +1.4+1.4, +0.7+0.7, and +1.5+1.5 points. Across these comparisons, the retrieval advantage is more consistent than the QA advantage. A.6 Does the Latent Memory Use Temporal Evidence? The aggregation controls retain the selected frames, backbone features, training setup, and objectives except for the component being ablated. Mean pooling, a recurrent aggregator, and a Transformer aggregator are compared with QASLR. Clip shuffling, reversal, and memory reset are applied only at test time, without retraining. The last-clip-only control retains the final clip of the selected chronological frame sequence and also does not retrain the model. Table 5: Aggregation, clip-order, and memory controls with Qwen3-VL-Embedding 2B. Variants use the same selected frames and backbone features, except that the last-clip-only control retains only the final clip. Alternative aggregators test pooling and additional modeling capacity, while QASLR controls perturb clip order or remove cross-clip memory. Ordered indicates chronological clip presentation, not whether an aggregator is sensitive to order; Persistent memory indicates retention of information across clips. Ret. Hit@1 is HourVideo retrieval Hit@1, and QA Acc. is EgoSchema accuracy. Scores are percentages, and bold numeric entries mark the highest value in each metric. Aggregator Ordered Persistent memory Ret. Hit@1 QA Acc. Mean pooling Yes No 58.6 60.2 Recurrent aggregator Yes Yes 63.5 61.8 Transformer aggregator Yes Yes 66.2 62.7 QASLR, shuffled clips No Yes 64.1 61.6 QASLR, reversed clips No Yes 65.0 61.9 QASLR, reset memory Yes No 60.3 60.8 QASLR, last clip only Yes No 56.9 59.7 QASLR Yes Yes 70.7 63.5 Relative to full QASLR, HourVideo Hit@1 decreases by 6.6 points with shuffled clips, 5.7 with reversed clips, 10.4 with memory reset, and 13.8 with only the last clip. QASLR exceeds the reported Transformer aggregator by 4.5 points. These controls support the usefulness of cross-clip state and chronological inputs under the evaluated settings. Because the perturbations are applied only at inference, the effects also include sensitivity to a change in the input or state-update distribution. A.7 Frame Budget and Streaming Depth The full-budget configuration uses K=128K=128 frames, L=16L=16 frames per clip, and eight memory updates. For inputs with fewer selected frames, QASLR reduces the number of frames per clip. Frame budget and clip size determine different aspects of processing: K controls the observations supplied to the backbone, while L controls per-call context length. For fixed K, changing L also changes the number of updates T=⌈K/L⌉T= K/L . At fixed L, increasing K changes both temporal coverage and total computation. These dependencies distinguish the storage occupied by the persistent memory from the cost of obtaining and encoding its evidence. A.8 Objective Ablations and Intermediate Embedding Quality We isolate the effects of step-wise contrastive supervision and final-embedding self-distillation using a 2×22× 2 objective ablation. The final contrastive loss is active in every configuration, and all other settings are identical across the four loss combinations. For text-to-video retrieval, the text query embedding is shared across steps and contrasted with each intermediate video embedding. For examples with unequal numbers of steps, padded steps are excluded from both the contrastive and distillation losses. Table 6 reports Hit@1 after 25%, 50%, 75%, and all selected clips. Mean checkpoint Hit@1 is the unweighted average of these four scores, summarizing intermediate and final retrieval quality without treating the checkpoints as an integrated curve. Table 6: Auxiliary-objective ablation and intermediate retrieval quality on HourVideo. The four Qwen3-VL-Embedding 2B configurations independently enable step-wise contrastive supervision and final-embedding self-distillation, with the final contrastive loss active throughout. Entries report retrieval Hit@1 (%) after processing 25%, 50%, 75%, or all selected clips; Final denotes the complete sequence. Mean H@1 is the unweighted mean of the four checkpoint scores. Bold numeric entries mark the highest value in each column, including intermediate and final performance. Step loss Distillation 25% 50% 75% Final Mean H@1 No No 43.8 54.6 62.8 67.9 57.3 Yes No 49.7 59.8 66.5 69.8 61.5 No Yes 51.2 61.7 67.9 70.1 62.7 Yes Yes 55.6 64.8 69.1 70.7 65.1 Negative construction. Consistent with the main objective, each query retains its paired target as the positive. Other valid co-positives from the same source video are excluded from the contrastive denominator, rather than added to a multi-positive target. The mask removes valid co-positives from the denominator while preserving the paired target. Final and intermediate effects. Adding step-wise supervision alone increases final HourVideo Hit@1 from 67.9 to 69.8; distillation alone increases it to 70.1; using both reaches 70.7. The corresponding changes at the 25% checkpoint are +5.9+5.9, +7.4+7.4, and +11.8+11.8 points. Relative to final-only supervision, the mean over the four checkpoints increases from 57.3 to 65.1 with both objectives. The combined final gain is 2.8 points, with larger improvements at the early checkpoint. Both objectives therefore improve partial-video readouts as well as the final embedding in this comparison. Partial evidence and distillation. An early clip may not yet contain the evidence needed for the paired target. Step-wise supervision therefore encourages a useful partial-video representation, rather than certifying that the answer is already observable. The final teacher also sees evidence unavailable at earlier steps. Alignment to that teacher is a training regularizer, not access to unseen frames at inference. Neither a high checkpoint accuracy nor a low average distillation loss guarantees correctness on every query or every candidate. A.9 Frame Selection and Evidence Coverage Q-Frame selects text-relevant frames within the input budget, and QASLR restores their chronological order before aggregation. The selector determines the available observations; the persistent memory combines their evidence across clips. Events omitted by selection remain outside the information available to the streaming head. A.10 Early Exit and Computational Cost Optional early exit. For local-clip QA, the optional stopping rule returns an intermediate readout at the first eligible step t≥tmint≥ t_ satisfying pt≥ηp_t≥η. If no eligible step meets the threshold, processing continues to the final readout. The fixed-length retrieval results use the complete sequence. The theoretical analysis below characterizes agreement with full-step predictions under its stated calibration assumption. Warm-cache latency. Table 4 reports per-query latency on NVIDIA H100 hardware with a warm cache. The two-stage single-round and QASLR configurations take 1.26 s and 1.72 s, respectively. QASLR improves HourVideo Hit@1 by 4.6 points in this comparison, with a latency increase of 0.46 s, approximately 36.5%. The uniform-selection rows compare configurations that additionally differ in sub-batching. Cost decomposition. For a shortlist R(q)C_R(q) containing at most R candidates, online processing comprises query encoding, search, candidate processing, and ranking: Conline(q) C_online(q) =Cquery(q)+Csearch(q)+Crank(q) =C_query(q)+C_search(q)+C_rank(q) +∑j∈R(q)[Cselect(q,j)+Cdecode(q,j)+Cencode(q,j)+Chead(q,j)]. + _j _R(q) [C_select(q,j)+C_decode(q,j)+C_encode(q,j)+C_head(q,j) ]. (15) This decomposition defines the full online workload separately from the warm-cache measurements above. Query-independent corpus encoding and index construction contribute offline costs, amortized as Coffline/QC_offline/Q over Q queries. Cached media can reduce repeated decoding, whereas query-conditioned video encoding remains specific to each query–candidate pair. A.11 Data Separation and Result Aggregation Source-video separation. The post-training and evaluation sets have zero overlap in source videos. This separation concerns the constructed post-training corpus and evaluation sets. QA uses original benchmark annotations, while classification and retrieval use the task-specific subsets described in Section A.3. Result aggregation. Experimental results are averaged over three random seeds. Differences between configurations are expressed in percentage points, and task-level averages use the metrics and task groups identified in each table. Retrieval metrics are interpreted within the candidate sets defined for each task. A.12 Complexity Analysis Let K be the selected-frame count, L the clip size, T=⌈K/L⌉T= K/L the number of steps, and D the backbone hidden dimension. The head uses N think tokens, at most M evidence tokens, and an output dimension d. Let Cvlm(L)C_vlm(L) denote one clip-encoding cost. For the cross-attention, fixed-width-ratio feed-forward network, and readout defined in Section 3, the per-step head cost is Chead=O(NMD+(N+M)D2+Dd).C_head=O\! (NMD+(N+M)D^2+Dd ). (16) The terms account for attention mixing, token projections and feed-forward transformations, and the output projection, respectively. This expression does not assume an additional latent self-attention layer. For full-step inference, Cfull=Cfixed+T[Cvlm(L)+Chead],C_full=C_fixed+T [C_vlm(L)+C_head ], (17) where CfixedC_fixed includes any up-front selection or preprocessing cost. In query-conditioned retrieval, clip encoding and aggregation are repeated for each query–candidate pair; first-stage retrieval and query encoding are additional costs. The persistent memory occupies O(ND)O(ND) values per example. Excluding model parameters and backbone activations, a conventional single-step attention implementation requires working space of order O((N+M)D+NM+d).O\! ((N+M)D+NM+d ). (18) These are inference-state bounds, not bounds on training peak memory. Backpropagation through the streaming head may retain activations across steps even when the backbone is frozen; checkpointing or recomputation changes that trade-off. If the model exits after T^≤T T≤ T steps, then, for fixed per-step cost and negligible gate overhead, [Cexit]=Cfixed+[T^][Cvlm(L)+Chead].E[C_exit]=C_fixed+E[ T] [C_vlm(L)+C_head ]. (19) When fixed costs are negligible, the remaining cost ratio is approximately [T^]/TE[ T]/T, and the saved fraction is 1−[T^]/T1-E[ T]/T. Up-front frame selection and decoding can reduce end-to-end savings relative to this approximation. A.13 Theoretical Analysis The following conditional results describe perturbation stability and agreement with full-step retrieval. They do not establish that optimization attains the stated assumptions or that QASLR is optimal. Assumption 1: regular memory update and readout. Let Ht=Uϕ(Ht−1,Et)H_t=U_φ(H_t-1,E_t). On the states under consideration, assume ‖Uϕ(H,E)−Uϕ(H′,E′)‖F≤ρ‖H−H′‖F+β‖E−E′‖F,\|U_φ(H,E)-U_φ(H ,E )\|_F≤ρ\|H-H \|_F+β\|E-E \|_F, (20) with ρ,β≥0ρ,β≥ 0, and assume the normalized readout is LRL_R-Lipschitz. For normalization, this requires the pre-normalization readout norm to remain bounded away from zero, in addition to regularity of the preceding operations. Proposition 1: propagation of evidence perturbations. Consider two executions with the same initial memory and ‖Et−E~t‖F≤ϵ\|E_t- E_t\|_F≤ε at every step. Under Assumption 1, ‖HT−H~T‖F≤βϵ∑k=0T−1ρk,‖zT−z~T‖2≤LRβϵ∑k=0T−1ρk.\|H_T- H_T\|_F≤βε _k=0^T-1ρ^k, \|z_T- z_T\|_2≤ L_Rβε _k=0^T-1ρ^k. (21) Proof. Writing δt=‖Ht−H~t‖F _t=\|H_t- H_t\|_F gives δt≤ρδt−1+βϵ _t≤ρ _t-1+βε. Unrolling from δ0=0 _0=0 yields the memory bound; applying readout Lipschitz continuity yields the embedding bound. □ If ρ<1ρ<1, the memory bound is at most βϵ/(1−ρ)βε/(1-ρ), uniformly in T. If ρ=1ρ=1, it grows linearly, and if ρ>1ρ>1, it can grow geometrically. The architecture alone does not verify a contractive update. Scope of step-wise supervision. The step-wise contrastive objective directly evaluates intermediate retrieval scores, whereas the final-only objective directly evaluates only the terminal readout. This distinction motivates intermediate supervision, but does not prove it is necessary for early exit. Nor does minimizing contrastive loss alone establish a prescribed distance to an ideal intermediate embedding. Both shared parameters and other auxiliary objectives can influence intermediate states without a step-wise contrastive term. Proposition 2: ranking preservation under an embedding-distance bound. For a fixed normalized query q, let p be the positive candidate and n index negatives. Define γt=q⊤ztp−maxnq⊤ztn. _t=q z_t^p- _nq z_t^n. (22) Suppose γT≥m>0 _T≥ m>0 and every candidate satisfies ‖zt−zT‖2≤ϵ\|z_t-z_T\|_2≤ε. If 2ϵ<m2ε<m, the step-t representation preserves the correct full-step top-1 decision. Proof. Cauchy–Schwarz gives |q⊤(zt−zT)|≤ϵ |q (z_t-z_T) |≤ε. The positive score can decrease by at most ϵε, and the largest negative score can increase by at most ϵε. Hence γt≥γT−2ϵ≥m−2ϵ>0. _t≥ _T-2ε≥ m-2ε>0. (23) □ For normalized embeddings, ‖zt−zT‖22=2(1−zt⊤zT)\|z_t-z_T\|_2^2=2(1-z_t z_T), linking the distillation objective to embedding distance. However, a small average distillation loss does not guarantee the uniform bound required for every candidate. The proposition assumes a fixed query and does not directly cover a simultaneously changing query-side embedding. Assumption 2: calibration conditional on the stopping history. Let ℱtF_t contain the information available to the stopping rule through step t, including the query, observed states, and previous gate outputs. Let AtA_t denote agreement between the step-t and full-step retrieval decisions. Assume the gate output ptp_t is measurable with respect to ℱtF_t and satisfies |pt−Pr(At∣ℱt)|≤ϵg |p_t- (A_t _t) |≤ _g (24) almost surely at every eligible step, with ϵg≥0 _g≥ 0 and 0≤η≤10≤η≤ 1. This history-conditional assumption is stronger than a small average calibration error. Proposition 3: disagreement risk at a threshold-based stopping time. Let T T be the first step t≥tmint≥ t_ with pt≥ηp_t≥η, or T if no earlier exit occurs. Under Assumption 2, Pr(AT^c)≤min1, 1−η+ϵg. (A_ T^\,c)≤ \1,\,1-η+ _g\. (25) Proof. For t<Tt<T, the event T^=t\ T=t\ belongs to ℱtF_t. On this event, calibration and the threshold imply Pr(Atc∣ℱt)≤1−η+ϵg (A_t^c _t)≤ 1-η+ _g. Since ATA_T holds by definition, Pr(AT^c) (A_ T^\,c) =∑t<T[T^=tPr(Atc∣ℱt)] = _t<TE\! [1_\ T=t\ (A_t^c _t) ] (26) ≤(1−η+ϵg)Pr(T^<T)≤1−η+ϵg. ≤(1-η+ _g) ( T<T)≤ 1-η+ _g. (27) A probability is also at most one. □ This is an agreement bound, not a guarantee of correctness against ground truth. It is conditional on Assumption 2, which is not verified by the reported experiments. A larger threshold delays or prevents exit for a fixed gate-output trajectory, but does not by itself prove improved task accuracy. Storage cost of index-only annotations. Suppose a video has R query annotations, each selecting K frames of size H×WH× W with c channels. If each raw pixel-channel value occupies s bytes and each index occupies b bytes, uncompressed frame copies require RKHWcsRKHWcs bytes. Index lists require RKbRKb bytes, giving an additional-annotation storage ratio of HWcsb. HWcsb. (28) Both approaches retain the original video. Compressed image formats, metadata, and caching alter the practical ratio; this comparison concerns duplicated annotation storage, not total dataset size or decoding latency. A.14 Limitations QASLR depends on frame selection: its latent memory cannot recover evidence that is absent from the selected observations. The query-aware pathway produces query-conditioned representations for bounded candidate scoring. Reusable corpus indexing instead requires query-independent selection and encoding. The comparisons with sub-batched single-round training show consistent retrieval gains but task-dependent QA gains. Test-time order and memory perturbations measure sensitivity to altered inputs and state updates, rather than identifying the internal reasoning process. Transfer is evaluated within the Qwen family. Warm-cache latency depends on selection, decoding, candidate count, and hardware. Fixed memory size bounds the persistent state, but does not imply a proportional reduction in total computation. The seed-averaged scores describe empirical differences without establishing statistical significance. Early-exit bounds concern agreement with full-step predictions under the stated assumptions, rather than unconditional ground-truth accuracy.