acceptodds
Under review as a conference paper at ICLR 2027

Sprout: Building Dynamic Memory While Reasoning for Agentic Video Understanding

Abstract

Long video understanding relies on video memory to overcome the context limits of multimodal large language models. Existing methods follow a build-then-reason pipeline: memory is built offline for the entire video, then reasoned over as a static source. In practice a long video is shared by several questions, and this pipeline is costly at both ends: with few questions, building memory for the whole video costs far more than answering them; with many questions, the memory is never updated, so what is learned while answering questions is lost to the next question. To alleviate these, we introduce Sprout, an agentic framework that builds memory while reasoning: a temporal tree that sprouts detailed nodes as questions are answered. The agent watches the video segment by segment at a low frame rate, stopping when the current question can be answered, remembers each segment as a coarse node of the tree, and revisits key intervals at a higher frame rate to refine the tree with the recovered details. Once a segment is recorded as text, its video input is removed from the interaction history, while the original video remains reachable through the video tools. The memory tree and prior question–answer records persist across questions, so the memory is online and dynamic: built from the first question onward and updated by every question thereafter. We find that replacing accumulated video inputs with textual memory substantially reduces context usage while maintaining accuracy, with slight improvements in some settings. Across benchmarks on three models, Sprout achieves competitive or improved accuracy relative to representative offline memory methods, with no upfront construction stage and lower context cost per question.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Video Understanding, Agentic Multimodal Large Language Model

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_734vOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes Sprout, an agentic framework that builds a temporal video-memory tree while answering questions. read_next provides coarse chronological coverage, write_chunk_memory stores textual memory nodes, and search_memory together with high-frame-rate revisits supplies targeted visual detail. The system removes video frames from the active conversation after recording textual observations, while retaining the memory tree and question–answer history for later questions. Across LVBench, Video-MME Long, Video-Holmes, and one EgoLifeQA recording, the reported results are competitive with or better than the listed memory baselines; the Gemini comparison also reports lower aggregate input/output tokens. The watch/remember/revisit abstraction is a useful systems contribution. The current evidence, however, does not yet determine how much of the accuracy gain comes from the proposed temporal memory mechanism rather than sequential question context, question order, amortization choices, or model/protocol differences.

Critical strengths
  1. The paper presents a concrete interface for online memory construction: coarse chronological coverage, targeted high-rate revisits, and write-back into a shared temporal tree. This abstraction is well suited to repeated questions about long videos.

  2. The evaluation spans three model families and several long-video settings, including LVBench, Video-MME Long, Video-Holmes, and EgoLifeQA. The frame-release, question-history, literal-versus-embedding retrieval, context-window, and token analyses make the system trade-offs more visible than a single end-task score would.

Critical weaknesses
  1. The reported accuracy gains are not yet attributable to the proposed memory mechanism (pp. 7–9, Tables 1–4). Sprout answers questions sequentially and exposes earlier questions and answers to later turns (p. 7), but the manuscript does not state whether the reported order is the benchmark order or a randomized order. Direct answers each question independently, while Qwen-MM-Plugins uses a different memory construction and model stack. Table 4’s Causal variant also changes several factors together: the first question receives the whole video, and later questions receive earlier questions, reasoning, and answers as text; the variant changes Video-Holmes by +3.9 points. This design does not isolate the tree or revisit/write-back mechanism. Table 2 introduces a separate protocol mismatch for EgoLifeQA: the direct baseline uses Gemini 2.5 Pro, whereas Sprout uses Gemini 3.8 Flash, and the paper does not report a same-backbone direct control. Equal-history, same-backbone controls and question-order sensitivity are needed before the headline causal claim can be assessed.

  2. The cost and reproducibility evidence does not yet support an independent comparison (p. 7 for implementation details; p. 9, Table 3, Appendix B). The reported offline construction cost is amortized over the benchmark question count, while Sprout’s cost depends on the number and order of prior questions. A per-video total and a break-even curve over the number of questions would make the comparison interpretable. Table 3 reports aggregate input/output token totals, but does not separate memory-writing and search calls, frame/image-token usage, wall-clock latency, model pricing, or monetary cost. The paper also reports single point estimates without uncertainty intervals and leaves important runtime details under-specified, including exact API model identifiers, decoding settings, retry and tool-failure handling, and the concrete search cap. Finally, Eq. (1) bounds the accumulated video-frame term; text memory, tool outputs, reasoning, and question history can still grow, so the corresponding context claim should be stated with that scope.

Questions for authors
  1. Were Direct and Qwen-MM-Plugins evaluated with the same question order and the same prior question–answer history available to Sprout? Please provide equal-history results under several random question orders, or report how the gains change when history is removed.

  2. For EgoLifeQA, can you report Direct and Qwen-MM-Plugins with the same Gemini 3.8 Flash and Qwen3.8-Max backbones, frame budgets, and prompts used by Sprout? Please state whether each external baseline in Table 1 was rerun under the same protocol or taken from its source.

  3. How are the values in Table 3 computed? Please separate per-video construction and per-question answering costs, state whether tool schemas, summaries, retries, and embedding calls are included, and report the break-even cost as the number of questions per video varies.

  4. What exact API model identifiers and access dates, decoding settings, retry and malformed-tool-call handling, search-count cap, round-cap behavior, and frame/token budgets were used for each model and baseline? These details are needed to interpret the single-run accuracy numbers.

  5. Can you provide no-history, no-revisit, flat-memory, and fixed-budget controls, together with retrieval precision/recall or a failure analysis of missed transient details and incorrect write-backs? These controls would show whether the improvement comes from the proposed memory mechanism rather than from additional model interaction.

5 comments
AuthorsOpenReview ↗

Response to Reviewer 734v

Thank you for your careful review and for recognizing the value of online memory across questions. Your suggestions on fair comparisons and reproducibility helped us clarify the evaluation. Below, we present additional comparisons and ablations, along with details of our experimental setup.

Weakness / Question:

  1. Performance without question history. (Weakness 1; Question 1)

    To separate the effects of question history and memory reuse, we compare shared and reset trees, each with and without question history. Resetting clears memory before each question.

    Memory treeQuestion historyLVBench Acc (%)LVBench Tokens (K)Video-Holmes Acc (%)Video-Holmes Tokens (K)
    SharedWith88.271.776.874.5
    ResetWith88.4163.576.5134.7
    SharedWithout87.981.573.882.1
    ResetWithout88.0176.473.6154.1

    Sharing the tree reduces token consumption by reusing visual observations across questions, while question history provides additional context that can improve accuracy and further reduce token usage.

  2. Same-backbone comparisons and baseline protocols. (Weakness 1; Question 2)

    On EgoLifeQA, we ran Qwen-MM-Plugins with both Qwen3.8-Max and Gemini 3.8 Flash, using the same frame budgets as Sprout. We have also added same-backbone Direct results for both models (51.4% and 53.6%) to Table 2. Baseline results in Tables 1 and 2 are taken from the original papers, except for entries marked with *, which come from our own reruns.

  3. Token accounting and memory construction cost. (Weakness 2; Question 3)

    Token accounting. Table 3 sums input and output tokens over all rounds of each question's final retained run, including tool schemas, video frames, generated summaries, and retrieved text. Sprout's online memory writes and searches are included in this total, and its literal matching requires no embedding calls. For Qwen-MM-Plugins, offline node-embedding tokens are included in Construction, while query-time embedding calls are not counted in Answering. API retries outside the retained run are excluded.

    Memory construction and break-even. For Qwen-MM-Plugins, offline construction averages 1,131K tokens per video on LVBench and 630K on Video-MME Long (75.2K and 210.0K per question in Table 3). On LVBench, Qwen-MM-Plugins' answering cost alone (95.3K) already exceeds Sprout's total cost (71.7K), so it never breaks even regardless of question count.

  4. Model settings, tool limits, and error handling. (Weakness 2; Question 4)

    Model settings. We summarize Sprout's API settings below. The dates refer to public releases or snapshots, not API access dates.

    ModelPublic release / snapshot dateTemperatureMaximum output tokens per call
    GPT-52025-08-071.065,536
    Qwen3.8-Max2026-08-030.765,536
    Gemini 3.8 Flash2026-09-02—65,536

    For Gemini 3.8 Flash, “—” indicates that the backend ignores temperature.

    Tool limits and error handling. Experimental Setup lists the frame budgets and the 32-round limit. At this limit, the agent must answer using the available evidence, as described in Method. Each question allows at most eight memory searches. Invalid tool calls return an error message so the model can correct them in the next round. Failed API requests are retried at most five times.

AuthorsOpenReview ↗

Response to Reviewer 734v

  1. Component contributions and qualitative analysis. (Weakness 1; Question 5)

    Component contributions. We add Sprout's components step by step with Gemini 3.8 Flash (Table 5). The first setting only reads video chunks and writes memory, using read_next and write_chunk_memory. The full memory is included in context. The second adds search_memory and removes the full memory from context. The agent then accesses memory through search.

    SettingLVBench Acc (%)LVBench Tokens (K)Video-Holmes Acc (%)Video-Holmes Tokens (K)
    Read and write memory only73.224.370.525.6
    + Search memory on demand73.835.671.731.4
    + Node revisiting and write-back87.586.272.688.6
    + Time-interval revisiting and write-back87.981.573.882.1
    + Question history (full Sprout)88.271.776.874.5

    Node revisiting and write-back substantially improve LVBench accuracy. Adding time-interval revisiting and write-back improves both benchmarks while reducing token use. Question history brings further gains.

    Qualitative analysis. Our case studies illustrate how memory search guides revisiting, and how revisiting recovers missing details or corrects errors in memory. In Appendix G (Fig. 10), Q4 retrieves the relevant event, but memory lacks the athlete's bib number. Revisiting recovers it. In Q15, Sprout revisits the result graphic and corrects a race time in memory from 10.08s to 10.09s before answering.

    Appendix H (Fig. 11) shows how memory search helps locate the relevant interval. Qwen-MM-Plugins revisits 10:55–11:45 and incorrectly answers Usain Bolt. Sprout locates 08:40–09:10 and identifies Anna Rogowska. Together, these examples show how memory and revisiting work together to support accurate answers.

  2. Scope of Eq. (1). (Weakness 2)

    We have updated Eq. (1) in Section 3.3 (Bt=B0+∑j=1tujB_t = B_0 + \sum_{j=1}^{t} u_j) to state its scope explicitly: releasing frames bounds the visual term, while the textual context BtB_t (prompt, question history, retrieved text, and per-round outputs) still grows across rounds and questions, with the memory tree itself kept outside the context.

We appreciate your time and thoughtful suggestions. Please let us know if any concerns remain; we would be happy to address them.

AuthorsOpenReview ↗

Friendly reminder from authors

Dear Reviewer 734v

Thank you again for your time and valuable feedback on our submission. As the discussion period is closing soon, we would like to gently check whether our rebuttal and the additional results have addressed your concerns. If any point remains unclear, we would be glad to respond promptly before the deadline.

Sincerely, Authors

Reviewer_ue5kOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

Sprout replaces the build-then-reason pipeline for long-video QA with build-while-reasoning: an agent watches the video in low-fps chunks only as far as the current question requires, writes each watched chunk into a temporal tree as coarse text nodes, releases the frames from context, and revisits stored intervals at higher frame rates to add finer child nodes when a question needs detail. The tree, watch record, and question–answer history persist across questions, so memory exists only from the first question onward and is refined by every later one. On LVBench, Video-MME Long, Video-Holmes, and EgoLifeQA with GPT-5, Qwen3.8-Max, and Gemini 3.8 Flash, Sprout matches or exceeds direct inference and offline-memory baselines while spending 71.7K/99.3K tokens per question versus 272.5K/222.2K for direct inference

Critical strengths
  1. The motivation maps cleanly onto the mechanism. Memory covers only what earlier questions actually looked at, so upfront construction cost disappears. The watch / remember / revisit loop with write-back naturally produces a coarse-to-fine tree. Releasing frames once they have been textualized is simple but effective: Figure 3 shows peak context dropping from 47.8K to 24.3K tokens with no loss in accuracy.

  2. The evaluation probes the cost claims from several directions. It uses three backbones and four benchmarks, including a 44.3-hour egocentric recording. Table 3 separates construction cost from answering cost. Ablations cover question history (Table 4) and retrieval type (Table 6). The per-question traces (Figures 4–9) show real reuse and self-correction, for example Q5 overwriting a 03:50 note with a verified 03:56.

  3. The results are consistent with the story. Gains are largest where the backbone handles long context worst (GPT-5 gains +13.0 over Direct on LVBench). Sprout also beats Qwen-MM-Plugins on all three backbones without paying any construction cost before the first question.

Critical weaknesses
  1. Each mechanism Sprout combines already appears in work that the paper neither cites nor compares against. VideoLucy (NeurIPS 2025) pairs a hierarchical memory, with granularity defined at each level, with agent-driven iterative coarse-to-fine backtracking, closely mirroring Sprout's remember / revisit / write-back loop. VCA (ICCV 2025) runs a curiosity-driven agent over a segment tree, looking coarsely first and collecting fine-grained frames only on demand. Deep Video Discovery (2025) builds a multi-granular video database and answers through global-, segment-, and frame-level search tools, the same retrieve-then-inspect toolchain as Sprout's. None of the three is in the reference list, and all were public well before the submission deadline, so "concurrent work" is not a satisfying explanation. Coverage of the cited literature is also thin. VideoTree gets one positioning sentence and no comparison, VideoAgent, DrVideo, and VideoSearcher appear only in related work, and VideoSeek, the sole agentic baseline in the main tables, is run with GPT-5 alone. Cross-question persistence and frame release may well be real differentiators, but against this literature they are asserted rather than demonstrated. I would like to see comparisons with VideoLucy, VCA, Deep Video Discovery, and VideoTree on at least one benchmark with a shared backbone. If that is infeasible, the paper should at least cite them and analyze what persistent memory and frame release add over per-query backtracking and multi-granular databases.

  2. Table 4 ablates only the question-history text, not the tree. Reuse of the tree is shown qualitatively (Figures 4–9) or indirectly through amortized watch cost (Table 3). There is no variant that resets the tree for each question, and no plot of accuracy or cost against question position within a video. It is therefore unclear how much of the gain over a single-question agent actually comes from the shared tree. I would ask for exactly these two analyses, with the reset variant run both with and without question history. I would also like to know how accuracy holds up on videos with only one or two questions, where most of the video stays unwatched.

Questions for authors
  1. Can you compare against VideoLucy, VCA, Deep Video Discovery and VideoTree on at least one benchmark with the same backbone? If code or protocols make this infeasible, please cite them and add an explicit analysis of what Sprout's cross-question persistent memory and frame release add over per-query hierarchical backtracking and multi-granular databases.

  2. How much does the shared tree contribute per question? Please report accuracy and tokens against question position within a video, and add a variant that resets the tree for each question, with and without the question history.

  3. What is the wall-clock latency per question and the distribution of rounds? How does accuracy hold up on videos with only one or two questions, where most of the video stays unwatched, and how sensitive is the system to chunk length and watch frame rate?

4 comments
AuthorsOpenReview ↗

Response to Reviewer ue5k

We appreciate your detailed review and your positive assessment of Sprout's motivation and memory reuse. Your comments on related work and controlled comparisons have been especially helpful. Below, we present new comparisons and ablations, together with further analysis of efficiency.

Weakness / Question:

  1. Related work and same-backbone comparisons. (Weakness 1; Question 1)

    Thank you for pointing out these closely related works. We have added a comparison with VideoLucy using Gemini 3.8 Flash for both methods on three benchmarks, and included these results in Table 1.

    MethodLVBenchVideo-MME LongVideo-Holmes
    VideoLucy86.089.370.8
    Sprout88.291.276.8

    We have now added published results for VCA, DVD, and VideoTree to Table 1, cited all four works, and expanded the discussion of their mechanisms in Related Work. We did not rerun these three methods on Gemini 3.8 Flash because VCA's code is unavailable, while DVD and VideoTree rely on separate auxiliary encoders and embedding models.

    Mechanism comparison. VideoLucy and DVD build an offline multi-granular database over the whole video before answering, while VCA and VideoTree explore a tree per query from scratch. In both cases, fine-grained details inspected for one question are not written back for subsequent questions. In contrast, Sprout builds memory online only as far as questions require and writes revisited details back into a shared tree, eliminating upfront indexing cost and reducing repeated inspection across questions (Table 3, Appendix D). Moreover, by recording watched and revisited clips as persistent text before releasing frames, Sprout halves peak context usage without losing recovered visual details (Fig. 3).

  2. Contribution of the shared memory tree. (Weakness 2; Question 2)

    The main benefit of sharing the memory tree is reducing token consumption by reusing observations across questions. Later questions can retrieve facts already recorded in the tree, avoiding repeated viewing and summarization of the same video segments.

    To separate this benefit from question history, we compare shared and reset trees, each with and without prior question–answer history, using Gemini 3.8 Flash. The reset variant clears memory before each question.

    Memory treeQuestion historyLVBench AccLVBench TokensVideo-Holmes AccVideo-Holmes Tokens
    SharedWith88.271.776.874.5
    ResetWith88.4163.576.5134.7
    SharedWithout87.981.573.882.1
    ResetWithout88.0176.473.6154.1

    Sharing the tree saves tokens by reusing video observations, while question history provides additional context that can improve accuracy and further reduce token usage.

AuthorsOpenReview ↗

Response to Reviewer ue5k

  1. Inference latency, single-question performance, and parameter sensitivity. (Question 3; also the few-question concern in Weakness 2)

    Inference latency and rounds. We report the observed response time and round distribution per question with Gemini 3.8 Flash below (Appendix E, Table 10).

    BenchmarkMean roundsMedian roundsP90 roundsMean time (s)
    LVBench8.10517331.6
    Video-MME Long9.27720268.7
    Video-Holmes10.26821115.5

    The measured time spans from the first response to the final response under 32–64 concurrent videos and includes video decoding, frame extraction, network delays, and API response times.

    Single-question performance. Our reset-tree experiment without question history also tests the single-question setting. Each video–question pair is processed independently, with a fresh tree and reset watch progress. As shown in the ablation table in Question 2 above, accuracy remains close to the shared-tree variant without history (88.0% vs. 87.9% on LVBench), while spending 176.4K tokens—still 35% fewer than Direct (272.5K) because most of the video stays unwatched after early stopping.

    Parameter sensitivity (chunk length and watch frame rate). We also evaluate chunk length and coarse frame rate on LVBench using Gemini 3.8 Flash, changing one parameter at a time while keeping all other settings fixed (Table 6).

    With the coarse frame rate fixed at 0.1 FPS:

    Chunk length (min)Accuracy (%)Tokens per question (K)
    588.374.2
    10 (default)88.271.7
    2087.970.1

    Shorter chunks slightly improve accuracy but consume more tokens. We choose the intermediate length of 10 minutes to balance accuracy and token cost.

    With the chunk length fixed at 10 minutes:

    Coarse FPSAccuracy (%)Tokens per question (K)
    0.0588.071.2
    0.1 (default)88.271.7
    0.288.276.6

    Higher coarse FPS provides little improvement in accuracy while increasing token usage. Increasing FPS from 0.1 to 0.2 leaves accuracy unchanged at 88.2% but raises token usage from 71.7K to 76.6K per question. We therefore use 0.1 FPS by default.

Thank you again for your constructive feedback. Please let us know if you have any further concerns; we would be happy to address them.

Thank you for your response. Your rebuttal has addressed most of my concerns, so I have decided to raise my score to 4. However, I have a few suggestions regarding the layout and formatting that I hope you will consider:

  1. The captions for Figures 1 and 2 are a bit too long; please make them more concise.
  2. Try to avoid leaving just a few words on the last line of a paragraph (ideally, the text should take up more than half a line), as seen in lines 97, 278, 298, 448, 473, etc.
  3. Please align the bottom horizontal lines of Tables 3 and 4.
  4. Consider using bold text, colors, or underlining in the tables to highlight key data and make the results more intuitive. Additionally, the table captions could also be more concise.
AuthorsOpenReview ↗

Official Comment by Authors

We sincerely appreciate your time, valuable feedback and continued support in raising the score. We have adopted your suggestions on the layout and formatting in the revised manuscript.

Reviewer_a7vyOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2(+1)
Read review
Paper summary

This paper proposes an agentic framework with memory that is built offline for the entire video. The paper raises a few challenges to solve: 1) building the whole memory for few questions is expensive; 2) the memory is not updated for previous questions. The paper proposes to i) construct a temporal tree with nodes tracking details in answered questions; ii) summarize the video with low FPS segment by segment as a coarse node in the tree, early stop when the question can be answered and revisit key clip of video when high FPS is necessary. iii) the video is removed after a segment is constructed. The framework is evaluated on benchmarks such as LVBench, Video-MME Long, Video-Holmes on models GPT5, Qwen3.8-Max, and Gemini 3.8 flash.

Critical strengths

Sprout uses 74% and 55% fewer tokens than Direct on LVBench and Video-MME-Long. The method is easy to understand.

Critical weaknesses

Lacks controlled study and breakdown of the framework and how each component works. For example,

  1. different coarse FPS and corresponding accuracy?
  2. whether discard video frames and keeping text only really hurt the performance (any failure example; not just a statistical mean of the result)?
  3. accuracy/analysis of detecting a segment? cases of failure of locating a segment that hurts fine-grained revisiting?

I guess the framework is developed on the benchmarks, any study of hold out benchmark for generalization of the framework?

Questions for authors

why in Table 1 two numbers are missing ? why in Table 2 GPT5 is missing for every framework?

2 comments
AuthorsOpenReview ↗

Response to Reviewer a7vy

Thank you for taking the time to review our work and for recognizing Sprout's token efficiency and the clarity of the method. Your suggestions have helped us strengthen the experimental analysis. We provide additional results and concrete examples below to address your concerns.

Weakness:

  1. Different coarse FPS and corresponding accuracy.

    We evaluate different coarse frame rates on LVBench using Gemini 3.8 Flash, fixing the chunk length at 10 minutes and keeping all other settings unchanged.

    Coarse FPSAccuracy (%)Tokens per question (K)
    0.0588.071.2
    0.1 (default)88.271.7
    0.288.276.6

    Higher coarse FPS provides little improvement in accuracy while increasing token usage. In particular, increasing FPS from 0.1 to 0.2 leaves accuracy unchanged at 88.2% but raises token usage from 71.7K to 76.6K per question.

  2. Qualitative analysis of frame release.

    To further examine the effect of frame release, we added three case studies in Appendix G (Fig. 10). When memory contains the required information, Sprout answers directly from text, as in Q2. When a detail is missing or incorrect, it revisits the relevant interval: Q4 recovers an athlete's missing bib number, while Q15 corrects a race time from 10.08s to 10.09s. In Q15, the corrected value is written back to memory, and Sprout answers correctly from the updated text after releasing the frames. These cases illustrate how textual memory and targeted revisiting work together, without requiring the text to preserve every visual detail.

  3. Analysis of segment localization.

    Sprout uses temporal memory to locate relevant events before revisiting them for finer details. We illustrate the importance of this step through a comparison with Qwen-MM-Plugins, using Gemini 3.8 Flash for both methods (Appendix H, Fig. 11).

    The question asks who appears first after Men's 100m Round 1 Heat 2. Qwen-MM-Plugins revisits a later interval, 10:55–11:45, and incorrectly answers Usain Bolt. Although it also retrieves Anna Rogowska by name, it does not inspect her earlier appearance. Sprout uses the stored events around Heat 2 to locate the transition to pole vault. It then revisits 08:40–09:10, reads Anna's name, and answers correctly. This case shows how selecting the relevant interval guides visual verification. It does not isolate the effect of retrieval alone, since the methods also differ in memory construction and question history.

  4. Generalization to held-out benchmarks.

    Our initial experiments on LVBench helped us assess the design choices in Sprout. We then evaluated the method on Video-MME Long, Video-Holmes, and EgoLifeQA without specific tuning. These benchmarks cover different settings. Video-MME Long tests understanding of long videos across diverse topics. Video-Holmes requires reasoning across visual clues in short suspense films. EgoLifeQA tests recall of daily events from first-person recordings spanning multiple days. These results provide evidence of generalization across video domains, lengths, and reasoning tasks.

Question:

  1. Why are two results missing from Table 1?

    Most baseline results in Table 1 are taken from the original papers. The two missing entries are the Video-Holmes results for WorldMM and MERIT, which were not reported in their papers. We use dashes to indicate these unreported results.

  2. Why are GPT-5 results missing for all frameworks in Table 2?

    The GPT-5 API rejected requests for some EgoLifeQA questions due to its safety checks, preventing us from completing the evaluation. We therefore do not report GPT-5 results in Table 2. Qwen3.8-Max and Gemini 3.8 Flash were both leading models at the time of our study. The further gains achieved by Sprout show that our method can improve even these strong models.

Thank you again for the valuable suggestions that have helped us improve the paper. Please feel free to raise any further concerns; we would be happy to address them.

AuthorsOpenReview ↗

Friendly reminder from authors

Dear Reviewer a7vy,

Thank you again for your time and valuable feedback on our submission. As the discussion period is closing soon, we would like to gently check whether our rebuttal and the additional results have addressed your concerns. If any point remains unclear, we would be glad to respond promptly before the deadline.

Sincerely, Authors

Comments on the paper

1 comment
Area_Chair_Q1v1OpenReview ↗

Friendly reminder from AC

Dear Reviewers,

Thank you for your reviews of this submission. The initial ratings are 2 / 3 / 2, so the paper is currently borderline. The authors have now responded to every review. The rebuttal includes several new results that bear directly on the concerns raised.

Please read the response and post a reply in the discussion. In particular, please tell us whether your concerns have been addressed and whether your assessment has changed. If any issues remain, please state them specifically so that the authors can still respond. Since the ratings are split, it would also help a great deal if you could comment on the other reviewers' points.

Thank you for your time and contributions.

Best regards, AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.