VideoTIR: Accurate Understanding for Long Videos with Efficient Tool-Integrated Reasoning

Conference: ECCV 2026
Paper: ECCV 2026
Area: Multimodal VLM / Video Understanding
Keywords: long video understanding, tool-integrated reasoning, agentic RL, multi-turn retrieval, credit assignment

TL;DR

VideoTIR answers long-video questions inside a multi-turn loop: it starts from a low-resolution, low-fps view, lets a textual router decide whether the current evidence suffices, and otherwise calls hierarchical internal visual tools (a global browsing tool plus a segment→frame→zoom-in grounding chain) whose output is folded back into context; TAGPO then decays the trajectory-level reward onto each individual tool call according to its distance from the final answer, curbing both tool overuse and misuse and improving accuracy and efficiency (1.42 tool calls, 4.6s latency) on Video-MME / MVBench / LongVideoBench.

Background & Motivation

Long video understanding (LVU) asks questions about videos ranging from minutes to hours, and MLLMs have become the mainstream answer thanks to their vision-language reasoning ability. Yet feeding a long video in and answering in one shot produces hallucinations, rooted in the imbalance between textual and visual tokens: a constrained context window forces aggressive subsampling, which erases cross-scene dependencies and amplifies duration-induced errors. Prior work attacks this from two directions. Non-TIR frame selection picks relevant frames or clips before the final reasoning pass; it does cut redundant visual tokens, but it runs outside the reasoning loop and cannot adaptively acquire evidence mid-inference. Tool-integrated reasoning (TIR) instead wires retrieval tools into the reasoning chain so evidence can be gathered iteratively — and this branch splits again. Heavy external toolkits couple the MLLM with ASR, OCR, segment localizers, or memory systems (VideoAgent, DrVideo, Video-MultiAgents, COLT); they rely on predefined workflows with high interaction overhead and generalize poorly to unseen long-video scenarios. Lightweight internal retrieval lets the MLLM emit textual timestamps that guide clip extraction (VideoMTR, LongVT); it is tighter, but it entangles localization with reasoning inside one text-decoding process.

That is the core tension this paper attacks: accuracy demands iterative evidence gathering, evidence gathering demands a reliable tool — but an external tool is expensive and rigid, while an internal tool tends to degenerate into "guessing timestamps in text", with precision capped by the base model's own temporal grounding ability (MLLMs are simply not pretrained on finely spatio-temporally annotated video). The symptom is repeated invocation over similar segments with no guarantee of a better answer. Worse, these methods effectively have a single tool, while long-video questions are heterogeneous: "what is the whole video about" and "what happened after the person claps" need completely different granularities of evidence, which one tool cannot supply on demand.

The angle this paper takes is that a tool need not be an external service — it can be part of the model's own encoders. Comparing textual query tokens against video tokens by cosine similarity inside the VLM's own embedding space is enough to localize segments, pick keyframes, and crop the most relevant region, with no external process at all; a textual router then decides across turns whether the model can answer now and, if not, which family of tools to call. Core idea: cast long video understanding as a multi-turn, multi-internal-tool decision process, learn the tool-use policy with RL, and let TAGPO distribute the trajectory-level reward onto each call — decayed by its distance from the final answer and normalized within the same tool — so that redundant calls receive negative advantage while exploratory repeats in failed rollouts receive none, simultaneously curing tool overuse and misuse.

Method

Overall Architecture

VideoTIR takes a long video and a question (multiple-choice in the benchmarks) and outputs an answer, with the whole reasoning unrolled multi-turn inside the VLM. It mimics how a human watches a long video: skim first, then go back for detail when the skim is not enough. For efficiency the initial view is deliberately coarse (by default up to 32 frames per video, 196 tokens for each frame in the first turn, roughly 1960 video tokens overall), and it is handed to the textual router together with the question. The router makes one of three choices: answer directly if the visual evidence suffices; call the global browsing tool, which raises resolution and frame rate together, if the question's intent is global ("what is the whole video about"); or enter the temporal-spatial grounding tool chain — segment retriever → frame retriever → zoom-in retriever — if the intent targets a specific visual clue. Any level of the chain may stop early once enough evidence is in hand. Whatever the tools return is folded into the existing context and fed to the router again, looping until the model produces an answer or hits the maximum number of turns (4).

Two more components live on the training side. Sandbox trajectory synthesis manufactures multi-tool cold-start data before RL using an external MLLM plus pseudo environment feedback — without it small models cannot even emit a syntactically valid tool call. TAGPO then breaks the trajectory-level reward down onto individual tool calls during RL, trading finer credit assignment for shorter tool-call chains.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400, 'subGraphTitleMargin': {'top': 8, 'bottom': 16}}}%%
flowchart TD
    Q["Long video + question<br/>low-res, low-fps initial view"] --> R["Textual router"]
    R -->|"evidence suffices"| ANS["Answer"]
    R -->|"global question"| BR["Global browsing tool<br/>raise resolution and fps together"]
    R -->|"local detail question"| TG
    subgraph TG["Temporal-spatial grounding tool chain (early stop)"]
        direction TB
        SR["Segment retriever<br/>text tokens vs. video tokens"] --> FR["Frame retriever<br/>pick keyframes inside the segment"]
        FR --> ZI["Zoom-in retriever<br/>crop the most relevant region"]
    end
    BR --> CTX["Visual clues folded back into context"]
    TG --> CTX
    CTX -->|"below max turns"| R
    ANS --> TR["TAGPO<br/>stepwise reward per tool call"]
    SYN["Sandbox trajectory synthesis<br/>pseudo-feedback multi-tool traces"] -->|"cold-start SFT"| R

Key Designs

1. Textual router: decide whether the current view suffices, then route to a tool family

If every question were answered after looking at all frames at full resolution, long-video visual tokens would blow up; yet a fixed tool pipeline cannot fit heterogeneous questions. The textual router puts the "do I need more information" decision inside the language model's own generation rather than in an external rule: combining the current visual clues with the textual intent, it emits one of three behaviors — answer directly when the evidence is enough, call the browsing tool when the intent is global, call the grounding chain when the intent points at a specific visual clue. It doubles as a query generator: grounding tools need a textual query, and that query is planned by the router (the retrieval sentence generated in the paper's Fig. 2 is "snatch grip deadlift gym background activity") before being handed to the internal encoders for similarity search. Merging routing and query rewriting means tool calls carry question semantics instead of mechanically raising the sampling rate — and the ablations show the router really does split traffic by question type.

2. Global browsing tool: trade resolution + frame rate for one slower, closer look

This targets "whole-video understanding" questions: when the question requires integrating the entire video while the current low-resolution, low-fps view cannot support an answer, a human slows down and looks more carefully. The browsing tool is exactly that action — it changes no tool type, it simply raises both resolution and sampling frame rate, re-feeding the same video with denser frames and larger pixels. "Global understanding" thus becomes a re-sampling with increasing cost rather than a one-off full budget: the token bill is paid only when the router judges it necessary. Sharing the same internal encoders as the localization tools, it introduces no extra model or process.

3. Temporal-spatial grounding tool chain: an early-stopping segment → frame → zoom-in internal retrieval

Local questions need "locate, then look closely", which the paper builds as a three-level chain that can stop early. The segment retriever selects relevant clips in the original video by cosine similarity between textual query tokens and video tokens — note that retrieval happens in the VLM's own embedding space, with no external retrieval model or API. The frame retriever then picks, inside that segment, the keyframes most relevant to the question and the retrieval sentence, tightening the temporal granularity. The zoom-in retriever finally operates on the image modality, cropping and enlarging the most relevant region. Each level continues only when the previous one proved insufficient, so "how fine must the search be" is decided by the model on demand (the paper's Fig. 4 illustrates the "That's enough" exit). The crucial contrast with both prior families is the division of labor: timestamp-based methods entangle localization with reasoning in a single text-decoding process and inherit the base model's temporal weakness, while external-tool methods pay for inter-process calls and a fixed workflow. Here localization is delegated to encoder feature similarity (a far more reliable signal) and the decision to keep digging is left to language reasoning.

4. TAGPO: break the trajectory-level reward down onto every tool call

With multiple tools, standard GRPO assigns a single episode-level reward to the whole trajectory (answer correctness + format + a tool-use bonus), which indulges two bad behaviors at once. Misuse means invoking a pile of tools and still answering incorrectly — reward hacking that inflates the early exploration burden. Overuse means the model's tendency to retrieve the finest-grained frames even when coarse retrieval would do. TAGPO pushes credit assignment down to each individual call. For tool \(k\) invoked at step \(j\) of trajectory \(\tau_i\), it first defines a local reward that is non-zero only when the trajectory is correct and that decays exponentially with the distance to the final answer:

\[R^{k}_{i,j} = \mathbb{I}_{R_{\mathrm{acc}}(\tau_i)>0}\cdot \gamma^{\,L_i-j}\cdot R_i,\qquad \gamma\in(0,1]\]

where \(L_i\) is the number of tool calls in the trajectory and \(\gamma\) a predefined decay coefficient: calls closer to the final answer get larger weight, earlier ones are decayed harder. The per-call advantage \(A^k_{i,j}\) is then obtained by normalizing within the same tool (only over steps where tool \(k\) was called), and the trajectory-level toolkit action advantage \(A^{\mathrm{TAGPO}}_i\) is the mean of those per-call advantages. Three comparative cases reveal the intent. If (A, A, B) and (A, B) both succeed, the second A of (A, A, B) earns the same local reward as the single A of (A, B), while the extra early A is decayed further and therefore becomes negatively advantaged under intra-tool normalization — overuse is directly punished. If (A, A, B) succeeds but (A, B) fails, every call in the former gets positive credit and every call in the latter gets zero, reinforcing the necessity of repeating A. If both fail, no local credit is assigned at all, so no relative advantage exists and the model is pushed toward exploring other tool combinations — the suppression of misuse. The policy is finally updated with the composite advantage \(A^{\mathrm{GRPO}}_i + A^{\mathrm{TAGPO}}_i\).

5. Sandbox trajectory synthesis: manufacture multi-tool cold-start data from pseudo environment feedback

RL rewards cover only "is the answer right" and "does the call string parse", providing almost no supervision on whether tool use was appropriate; meanwhile, in multi-tool settings the tool prompts sit far from the initial system prompt, sharply raising the risk of instruction drift or forgetting — especially for small models. The paper reports that Zero-RL on the 3B model simply fails, because valid tool-call strings are so rare that the in-group standard deviation of advantages is near zero and the advantage estimator breaks down. The fix is to synthesize the data first. Question-answer pairs are built from video-text grounding datasets (VideoXUM, QV-Highlights, etc.); an MLLM answers each item directly once for tool necessity filtering, and items solvable without tools are set aside. For the rest, the VQA item and an initial system prompt carrying the toolkit template are given to an external MLLM (GLM-4.5V) to predict a plausible tool invocation order. The system prompt — especially the toolkit template — is then rewritten to diversify calling syntax and reasoning behaviors. Conditioned on the rewritten prompt and the predicted order, the MLLM produces stepwise reasoning traces, explicit invocation commands, and expected environment feedback (i.e., pseudo tool returns) inside a sandboxed simulator, which removes the need for real environment interaction. Finally a large LLM ranks and adjudicates candidate trajectories by conciseness and precision, keeping only the reasonable ones. The resulting trajectories serve as the cold-start SFT set: first teach the model to format a tool call, then let RL learn whether to call one.

A Worked Example

Take the multiple-choice item in the paper's Fig. 2: the video is a gym scene and the question is "After the man started lifting weights, what else was happening in the gym?", with option A being "a woman began running on a treadmill behind him".

Turn 1: the model receives 8 low-resolution frames (about 1960 tokens). In its <think> block it reasons that the user wants to know what else happened in the gym after the main subject starts lifting, that the background detail is unclear in the current frames, and that a retrieval tool should help — so it plans the retrieval sentence "snatch grip deadlift gym background activity" and emits a <tool_call> to temporal_retriever_tool (topk = 1). Turn 2: the segment retriever returns a higher-resolution crop in which other activity in the gym becomes visible, but the clue is not yet pinned down, so the model continues down the chain into the frame retriever and then the zoom-in retriever. Turn 3: with the enlarged local view, the model confirms in <think> that the cropped image shows a gym section with visible exercise equipment and background activity, decides that is enough, and emits <answer>A</answer>, terminating the loop. The whole chain takes 2–4 turns and 1.42 tool calls on average, instead of pushing every frame to the highest resolution.

Loss & Training

Training has two stages. Cold-start SFT (mainly for the 3B model): trajectories are synthesized from NextQA/NextGQA, PerceptionTest, and the VTG datasets VideoXUM / QV-Highlights; 4.5k tool-invoking trajectories are combined with three times as much textual CoT data (from Video-R1) for a total of 17,384 examples. For the 3B model the paper also compares Normal-SFT against Random-Noising-SFT, where the visual modality is replaced by placeholders and masked at the attention level. Agent RL: 4.5k training samples for 3B and 9k for 7B, curated by difficulty estimation (samples answered correctly 3–7 times out of 10) and ground-truth verification; max turns is 4 with 8 rollouts per sample, the Zero-RL and SFT cold-start settings use different reward coefficients (after SFT the format-following ability already starts high, so the model should learn more from the other rewards), and online rollout filtering is used for training stability. The objective is policy gradient with the composite advantage:

\[\mathcal{L} = -\sum_{i}\left(A^{\mathrm{GRPO}}_i + A^{\mathrm{TAGPO}}_i\right)\nabla_\theta \log \pi_\theta(a_i \mid s_i)\]

where \(a_i\) denotes the action (output tokens) of the base model and \(s_i\) the environment state (⚠️ the original Eq. 4 is badly mangled in the extracted text this note was written from; the notation here is reconstructed from context). On hardware, SFT uses 8×NVIDIA 4090 (Normal-SFT) / 2×AMD MI308X (Random-Noising-SFT), and RL uses 8×NVIDIA H20 with VeRL for the 7B Zero-RL model and 4×AMD MI308X for the 3B models, all within LLaMA-Factory.

Key Experimental Results

Main Results

Evaluation spans three long-video benchmarks: Video-MME without subtitles (2700 items), MVBench (4500 items), and the LongVideoBench validation set (1377 items). In the table "Low" matches the training budget (1960 video tokens) while "High" is 1 fps sampling (up to 32 frames, 16384 video tokens). † follows the observation of [48] that enabling thinking mode degrades LVU performance in MLLMs below 7B; thinking-mode results are reported for fairness.

Model	Size	Input	Res.	Thinking	Video-MME (mean)	MVBench	LVBench
Qwen2.5-VL (base)	3B	16-frame	High	×	54.0	60.9	51.8
Qwen2.5-VL (base)	7B	16-frame	High	×	53.8	60.6	51.8
Qwen2.5-VL (base)	7B	16-frame	High	✓	49.5	55.2	47.5
Qwen2.5-VL (base)	7B	8-frame	Low	✓	35.0	40.3	28.1
Video-XL	7B	128-frame	High	✓	55.5	55.3	50.7
Video-MTR	7B	32-frame	High	✓	–	59.0	–
LongVT-RL ‡	7B	64-frame	High	✓	–	66.1	–
VideoTIR w/ Tool (zero-shot)	7B	8-frame	Low	✓	42.9	47.8	38.6
VideoTIR w/ Tool + GRPO	7B	8-frame	Low	✓	54.1	56.9	50.9
VideoTIR w/ Tool + TAGPO	7B	8-frame	Low	✓	54.2	56.0	51.3
VideoTIR w/ Tool + TAGPO	7B	16-frame	High	✓	57.9	64.3	53.1

‡ This method is SFTed on roughly 100k TIR and non-TIR trajectories.

Ablation Study

Efficiency comparison (paper Table 3): external-tool methods either call GPT-4o / Gemini APIs or run 8 specialist models, whereas VideoTIR's internal tools are built directly on the backbone encoders, avoiding inter-process overhead and enabling GPU parallelization.

Method	Tool type	Avg. tool invocations	End-to-end latency (↓)
VideoMA	External API (GPT-4o / Gemini)	3 †	27.4s
COLT	External tools (8 specialist models)	3 †	68.3s
VideoMTR	Internal retrieval	2 †	5.9s
VideoTIR	Internal (backbone encoders)	1.42	4.6s

† These values are manually set by the original papers.

TAGPO / router / cold-start ablations:

Config	Metric	Value
7B + GRPO (30 steps, bs=32)	Validation accuracy	21.1
7B + TAGPO (30 steps, bs=32)	Validation accuracy	24.6
3B Zero-RL (no cold start)	Training status	Fails: valid tool-call strings are extremely rare, in-group advantage std ≈ 0
3B Normal-SFT	MVBench / VideoMME / LVBench (random 10%)	36.3 / 35.0 / 34.0
3B Random-Noised-SFT	Same	40.7 / 38.5 / 39.0
Router · Information Synopsis tasks	Browsing / retrieval chain / direct answer	309 / 1 / 13
Router · Object Recognition tasks	Browsing / retrieval chain / direct answer	3 / 335 / 16

Formatting quality vs. system prompt and training strategy (paper Table 2): under the long system prompt (carrying the full toolkit template) the 7B model still maintains a reasonable format-compliance rate while the 3B model is near zero; SFT cold start restores the 3B model above 90.

Model	System prompt	Format quality
Qwen2.5-VL-7B	Short	≤1.0
Qwen2.5-VL-7B	Long	81.7
Qwen2.5-VL-3B	Short	≤1.0
Qwen2.5-VL-3B	Long	≤1.0
Qwen2.5-VL-3B w/ SFT	Short	91.7
Qwen2.5-VL-3B w/ SFT	Long	90.1

Key Findings

• Tools + RL are the lever that pulls a low budget up toward a high one, but not an across-the-board win. At the same 8-frame low-resolution setting (1960 tokens), the untrained tool model scores only 42.9 / 47.8 / 38.6, rising to 54.2 / 56.0 / 51.3 after TAGPO — roughly 19 points above the base model at the same budget (35.0 / 40.3 / 28.1). Moving to 16-frame high resolution reaches 57.9 / 64.3 / 53.1. Note that the non-thinking 16-frame High base model already scores 60.6 on MVBench, so the gain is best described as matching or beating the high-frame base on the average while spending far fewer visual tokens, not as dominating it on every benchmark.
• On MVBench the method still trails LongVT-RL (64.3 vs 66.1). LongVT-RL takes 64 frames and is SFTed on roughly 100k TIR trajectories, i.e. "more frames plus more supervision"; the paper's claim is about efficiency and about comparisons at equal budget, so this cross-comparison needs the frame-budget and training-data caveats attached.
• Efficiency is where the gap with external-tool methods opens. Average tool invocations drop from 2–3 to 1.42 and end-to-end latency from 5.9–68.3s to 4.6s; both numbers follow from retrieval happening inside the model's own embedding space rather than through cross-process calls to external models.
• TAGPO's benefit is largest early in training. At 30 steps with batch size 32 the validation accuracy is 24.6 versus 21.1 for GRPO; on the training curve the valid-tool reward rises faster, cutting the steps needed to exceed 0.45 by about 50%, while keeping a comparable number of tool invocations early on — it saves useless exploration, not tool usage.
• The router genuinely learns to split traffic by question type. On Information Synopsis tasks, which need global video understanding, it picks the browsing tool 309 times against a mere 1 retrieval chain; on Object Recognition tasks, which focus on local regions, the picture reverses with 335 retrieval chains and 3 browsing calls. Multi-tool capability is therefore exercised, not decorative.
• Format compliance in small models is the hard gate for TIR. The 3B model scores ≤1.0 format quality under the long system prompt and Zero-RL fails outright because the in-group advantage std ≈ 0; SFT cold start is mandatory. After cold start the RL stage can even use a lower format-reward weight, since the formatting ability acquired during SFT is stable enough.
• Random-Noising-SFT beats Normal-SFT (36.3→40.7, 35.0→38.5, 34.0→39.0). Replacing the visual modality with placeholders and masking it at the attention level actually yields higher validation accuracy while keeping format quality near 100. The detailed discussion sits in the supplementary material; the main text reports only the numbers (⚠️ mechanism explanation should be checked against the original supplement).
• Training dynamics show "explore first, regularize later". Early on, response length grows while format quality drops, indicating the model prioritizes rational tool exploration; once response length stabilizes, format quality climbs back, striking a balance between rationality and formality.

Highlights & Insights

• "Internal tools" reframes tool use from a systems-design problem into a model-internal one. Retrieval uses the VLM's own text/vision encoder embeddings, and similarity comparison is the localization; there is no API round trip, no specialist model to load, and everything parallelizes on the GPU. This is what pulls latency from tens of seconds down to 4.6s, and it is the most practically transferable lesson in the paper — anything the model's own encoders can do should not be outsourced to an external service.
• TAGPO covers both overuse and misuse with two operations — intra-tool normalization plus distance-based decay — and adds no extra network or value model. The second comparative case is especially clean: redundant calls in a successful trajectory pick up negative advantage while exploratory calls in failed trajectories get zero, all without ever labeling "redundancy" explicitly. The decay coefficient and in-group statistics separate them automatically.
• Putting tool-necessity filtering first is a quiet but critical step in the synthesis pipeline. By letting the model answer directly first and setting aside what it gets right, the RL set is not made up almost entirely of tool-calling samples — otherwise the model would learn that every question must start with a tool call.
• The Random-Noised-SFT finding is transferable. On a small trajectory set, swapping the visual modality for placeholders and masking attention improves downstream accuracy, a trick any pipeline doing cold start from a few multimodal agent trajectories can reuse directly.
• The overall paradigm generalizes: any "skim first, fetch detail when needed" task (long-document RAG, long audio, web agents) can adopt the router + hierarchical tools + tool-level credit assignment skeleton. TAGPO's reward form is task-agnostic, depending only on the tool-call sequence and the final correctness.

Limitations & Future Work

• The toolkit covers the visual modality only. Browsing, segment retrieval, frame retrieval, and zoom-in are all "look at the picture" tools; there is no ASR, OCR, or subtitle branch, even though Video-MME itself ships audio and subtitles (the paper deliberately evaluates the w/o-sub subset). Questions that depend on on-screen text or speech have no tool to serve them.
• The 3B model cannot do Zero-RL, and cold start depends on an external MLLM and a hand-designed sandbox. Every synthesis step (necessity filtering, order prediction, prompt rewriting, adjudication) is driven by GLM-4.5V, so the data quality ceiling is set by that external model — and the paper reports no quality evaluation of the synthesized data itself, only downstream metrics.
• Hyper-parameters are fixed with no adaptive budget. Max turns (4), max frames (32), and the 1960-token initial view are all constants; "efficient" currently means saving on call count and tool implementation rather than letting the model decide how many tokens to spend. Scalability to videos beyond an hour is not discussed.
• Comparison fairness has reservations. Against methods like LongVT-RL, the comparison mixes frame budgets and SFT data volumes (100k trajectories), so the result only supports "better at equal or lower budget"; there is no controlled comparison with a comparable TIR method at an identical frame budget.
• Several details are missing from the main text. Tool implementations (top-k per retrieval level, similarity thresholds, early-stop criteria) live in the supplement, and the tool-use bonus \(R_{\mathrm{tool}}\) is described only as "encouraging appropriate tool invocation" with a citation — no concrete form is given, so reproduction requires the supplement.
• The dataset naming is inconsistent in the paper: the main text says the data is curated from "LLaVa-Video-155k" while Fig. 7 labels it "LLaVA-Video-178k" (⚠️ refer to the original paper / supplement).
• Directions that could improve it: attach audio/OCR branches and route across modalities with the same router; let the router also choose the token budget (adaptive resolution/fps); and replace external-MLLM adjudication with automatic trajectory filtering based on the necessity/sufficiency of the tool-call sequence.

Related Work & Insights

• vs VideoMTR (multi-turn RL with a single tool): VideoMTR reinforces multi-turn reasoning, but its tool is still a single "emit a textual timestamp, then cut the clip" primitive, scoring 59.0 on MVBench with 32 frames. This paper swaps in a multi-level internal tool chain with feature-similarity retrieval, reaching 64.3 on MVBench at 16-frame High while cutting average tool calls from 2 to 1.42. The core difference is that localization is done by an encoder rather than guessed by the text decoder.
• vs LongVT / LongVT-RL (native tool calling): LongVT follows the RL-after-SFT cold-start route with 64-frame input and about 100k TIR trajectories, scoring 66.1 on MVBench — above this paper's 64.3. The difference here is a multi-level internal toolkit (rather than a single calling primitive) plus TAGPO explicitly optimizing the conciseness of the call chain, trading fewer frames and fewer calls for close accuracy.
• vs external-tool agents (VideoAgent / DrVideo / Video-MultiAgents / COLT): they assemble workflows from ASR, OCR, segment localizers, memory systems, or 8 specialist models, with fixed tool repertoires, multi-agent coordination, or structured memory decomposition, at 27.4–68.3s latency. VideoTIR's tools all live on the backbone encoders for 4.6s, at the cost of covering no audio or text modality.
• vs frame-selection methods: they decide once, outside the reasoning loop, which frames to look at; tokens are saved but evidence cannot be acquired mid-inference. This paper turns "take another look" into an explicit in-loop action, paying with multi-turn calls.
• vs GRPO / general agentic RL (DeepEyes, SimpleTIR, etc.): they rely on episode-level rewards plus a tool-use bonus, which in multi-tool settings indulges misuse and overuse alike. TAGPO's contribution is a pluggable, value-network-free tool-level advantage term that simply adds to the GRPO advantage.
• Insight: the router + hierarchical internal tools + tool-level credit assignment skeleton has nothing video-specific about it. Any multi-tool agent (search, code, browser) could port TAGPO's decayed local reward and let intra-tool normalization separate redundant calls from necessary exploration — a cheap, drop-in improvement.

Rating

• Novelty: ⭐⭐⭐⭐ The internal multi-level toolkit plus TAGPO's tool-level advantage estimation is a substantively new combination; the latter writes the penalty for redundant calls directly into the reward with no extra labels, which is a clean idea.
• Experimental Thoroughness: ⭐⭐⭐ Three long-video benchmarks plus analyses of efficiency, router behavior, SFT variants, and early TAGPO convergence, but no controlled comparison at an identical frame budget, and tool details plus part of the reward definition are pushed to the supplement.
• Writing Quality: ⭐⭐⭐ The method thread (multi-turn loop, tool hierarchy, reward design) is clear, but the equations are badly mangled in the extracted text and some symbols (e.g. \(R_{\mathrm{tool}}\)) are never defined in the main body; the figures and tables are extremely dense.
• Value: ⭐⭐⭐⭐ Tool-level credit assignment and the "internal tool" design are directly reusable for agentic video RL, and the efficiency figures (1.42 calls / 4.6s) are informative for real deployment.

Related Papers

• [ECCV 2026] Towards Temporal Compositional Reasoning in Long-Form Sports Videos
• [CVPR 2026] LongVT: Incentivizing "Thinking with Long Videos" via Native Tool Calling
• [ECCV 2026] MarineEVT: Advancing Event-Centric Marine Video Understanding via Visual Tool Reasoning
• [CVPR 2026] Thinking with Drafts: Speculative Temporal Reasoning for Efficient Long Video Understanding
• [ECCV 2026] Reasoning with Memory: A Temporal Granularity-Adaptive Framework for Training-Free Long Video Understanding