betaFeedback

WorksComputer Science

Tempo-Zero: Recursive Self-Play in Executable Worlds for Video Reasoning

Abstract

Video reasoning requires understanding how events unfold over time, yet videos with accurate temporal annotations are expensive to collect. Self-play offers an alternative by letting a model generate and solve its own tasks without manual annotation. However, existing video self-play methods train on fixed sets of recorded videos, so they cannot alter the underlying event dynamics and rely on noisy pseudo-labels derived from the model's own outputs, such as majority voting, that risk reinforcing shared model errors. To overcome these limitations, we introduce Tempo-Zero, a self-improvement framework that closes a loop of executable environments, execution-verified self-play, and environment evolution, where executing a program renders a video with the ground-truth option and interval of every question. A single policy plays both Questioner and Solver, proposing questions and answering them with timestamped evidence lines, and is trained on execution-grounded rewards instead of model consensus. The Solver's performance steers a curriculum over tasks and difficulty levels, and the policy selects rule changes that enrich the event dynamics of later rounds. Despite being trained solely on simple programs, without supervised fine-tuning or external video data which prior methods typically require, Tempo-Zero outperforms the base models and recent self-play baselines on average across twelve real-world video benchmarks at different model scales, with particularly strong gains on temporal grounding tasks. Project page: https://alchemist-jo.github.io/tempo-zero/

Project link: https://alchemist-jo.github.io/tempo-zero/

Introduction

Video understanding and reasoning require models to interpret dynamic events, track temporal dependencies, and perform multi-step inference over time [4, 12, 29]. While supervised fine-tuning and reinforcement learning for vision-language models have improved these capabilities [1, 4, 34], progress remains constrained by the cost of collecting diverse videos, designing multi-step tasks, and verifying temporal annotations [14, 29]. To reduce dependence on human annotation, self-improvement has emerged as a promising alternative paradigm, enabling models to construct their own training tasks and improve through self-generated feedback [13, 22, 43, 46].

Self-play provides a practical framework for self-improvement: a model proposes tasks, solves them, and updates its policy based on the outcomes of its attempts [2, 5, 31]. In text, it has improved coding and mathematical reasoning, with answers verified either through programmatic execution [43], by majority voting over sampled solutions [13], or against source documents [22]. Beyond text, image self-play derives answer labels either through majority voting [10, 32] or from the outcomes of visual games executed on rendered and edited images [35], yet static images lack temporal dependencies and continuously evolving states. Extending this recipe to video, frameworks such as Video-Zero [42] and EvoVid [15] train on fixed collections of pre-recorded, unannotated videos, which introduces two limitations. First, because these videos lack verifiable ground truth, answers are labeled from the model’s own outputs, for example by majority voting over responses sampled from the same model (Figure 1a), which risks reinforcing systematic errors shared across samples and propagating them through training. Second, the model can vary its questions but not the events it observes. Consequently, the event dynamics and temporal complexity of its training data remain fixed even as its reasoning improves.

Figure 1. Limitations of video self-play and program-generated video. (a) On a shell-game video, majority voting over eight sampled answers selects a wrong label over the two correct ones, while execution gives the correct label. (b) Under a fixed rule, all Solver rollouts are correct; changing the cushion rule and re-executing the program yields a new path with exact labels.

Executable programs offer a foundation for verifiable and controllable video self-play. In code self-play, executing a model-proposed program on an input yields an automatically verifiable answer [43]. For videos, an executable program produces both the visual input and its event trace: its entities and transition rules determine the event dynamics in the rendered video, while task templates construct questions from the recorded events. The trace therefore provides each question’s correct answer option and the exact time interval of the evidence needed to answer it [18, 39]. Thus, programs control both the videos shown to the model and the ground-truth supervision used to train it, and re-executing a program under changed rules updates both. Although program-generated videos already serve as training data, programs designed before training fix the templates, task allocation, difficulty, and event dynamics [3, 18]. The resulting training distribution cannot adapt to the learner’s changing strengths and weaknesses, limiting its exposure to appropriately challenging temporal structures needed for continued improvement (Figure 1b). Self-play on recorded videos thus adapts only its questions and cannot verify its labels, whereas program-generated video has verifiable labels but adapts neither its questions nor its events to the learner.

Based on these observations, we introduce Tempo-Zero, which turns executable programs into an evolving source of video experiences and verifiable supervision. The framework has three components. First, executable environments execute programs to render videos and produce their event traces. Each trace yields a set of verifiable criteria, each specifying a question, its correct answer, and the time interval of the event that determines that answer. To ensure that this supervision is available to a frame-based video model, we recompute each criterion on the sampled-frame timeline and discard it if its answer differs from the execution label. We also screen for temporal dependence by recomputing each criterion under reversed and permuted event order, removing criteria whose answers remain unchanged under both transformations. The retained criteria therefore describe events that the sampled frames show. Second, execution-verified self-play uses a single shared vision-language policy as both Questioner and Solver. The Questioner proposes questions linked to verified criteria, and the Solver answers them with timestamped evidence lines. Execution rewards the Questioner for valid questions near the Solver’s current capability and rewards the Solver for the correct answer, granting interval credit only when a cited line states the correct event, rather than relying on model consensus. Finally, environment evolution adapts not only which tasks are sampled but also what can happen in the videos. Pass rates reallocate training across tasks and difficulty levels, and the policy selects validated rule changes, whose re-execution generates new event dynamics together with recomputed answers and evidence intervals. Tempo-Zero therefore moves beyond asking different questions about fixed videos: it creates progressively targeted video worlds whose supervision stays exact. The loop is recursive: the policy trained in each round selects the rules that generate the videos and labels of the next round.

Our main contributions are summarized as follows:

  • Executable environments for video self-play. We formalize video task generation as program execution, where rule changes produce new event dynamics with ground-truth options and intervals, without recorded videos or manual annotations (§ 3.1).

  • Execution-verified self-play with environment evolution. One policy plays Questioner and Solver and learns from execution-grounded rewards instead of majority voting, while a pass-rate curriculum and policy-selected rule changes evolve the environments with the learner (§ 3.2–§ 3.3).

  • Performance gains on real-world videos. Trained solely on rendered videos, without supervised fine-tuning, Tempo-Zero improves over the base models on average across twelve real-world video benchmarks on four backbones from two model families and outperforms recent self-play baselines, especially in temporal grounding (§ 4).

Related Work

Self-play. Self-play has evolved from optimizing policies on self-generated responses to constructing tasks and evaluation signals autonomously. Early text methods contrast a model’s answers with reference demonstrations [5] or train it to score its own outputs [40]. Later frameworks split self-play into a Questioner and a Solver with feedback from code execution [43], majority voting [13], text corpora [22], or a guide model [2], and self-improving agents modify their own code [36, 41] or co-evolve their evaluators [16]. In the visual domain, image self-play labels answers by majority voting [10, 32] or by visual games [35]. Video self-play then brings time into the loop: Video-Zero adds temporal evidence to question answering [42], EvoVid rewards questions whose Solver confidence drops when frames are permuted [15], and video reinforcement learning rewards temporal order [6, 11] or cited evidence [24, 26]. These video methods, however, train on fixed collections of recorded videos and take their labels and intervals from annotations, model consensus, or the position of a sampled clip. Tempo-Zero removes both dependencies: it generates the videos from executable programs, so every label, including the time span of each event, is computed by execution rather than by model consensus, and its temporal checks screen these labels before any rollout.

Programmatic environments. Programmatic synthesis couples simulation with deterministic supervision and turns execution traces into verifiable ground truth. For video, SynRL synthesizes videos with automated temporal supervision [18], and SIMS-V [3] and SpatiaIEvo [20] turn 3D simulation into spatial question-answering targets. Executable code also represents worlds for physical reasoning [33] and video generation [21]. In SynRL and SIMS-V, however, the rules and question templates are fixed before training, so the data cannot follow the learner. Adaptive curricula address this gap: ACCEL mutates environment parameters [27], Prioritized Level Replay revisits levels with high learning potential [17], and SPADE trains agents to construct executable environments [23]. Tempo-Zero brings this adaptation to video self-play and closes the loop between the learner and its environments. Its pass rates steer the curriculum, the policy itself selects rule changes, and re-execution recomputes every video and label. The training distribution thus grows with the learner, and its supervision stays exact.

Method

Tempo-Zero trains a vision-language policy by self-play in an executable program library, where every label comes from program execution rather than majority voting (Figure 2). Programs first execute into rendered videos and verification criteria (§ 3.1). One policy then proposes and answers questions, and the execution trace scores both roles (§ 3.2). Finally, a pass-rate curriculum and policy-selected rule changes evolve the environments with the learner (§ 3.3).

Figure 2. Overview of Tempo-Zero. Programs in library P\mathcal{P} execute and compile into video vv, criteria C\mathcal{C}, and canonical question qˉ\bar{q}. One policy proposes questions as the Questioner and answers them as the Solver; bank B\mathcal{B} stores measured questions for replay, and execution-grounded rewards rQr^{Q} and rSr^{S} drive GRPO updates.

Problem formulation. We formalize video self-improvement as an interaction between two roles of a single policy πθ\pi_{\theta}: a Questioner πθQ\pi_{\theta}^{Q} that proposes questions and a Solver πθS\pi_{\theta}^{S} that answers them. The two roles share parameters θ\theta and differ only in their prompts, so visual representations learned while solving also inform question generation. Executing a program from library P\mathcal{P} yields a synthetic video vv with verification criteria CC, each recording a question stem, its ground-truth option, and the time interval of the event that decides it. With the criteria as the source of all rewards, the policy is trained to maximize

J(θ)≡Ew∼PEq∼πθQ(⋅∣w)rQ(q)+Eq∈Q, y∼πθS(⋅∣vq,q)rS(y,q),(1)J(\theta) \equiv\mathbb{E}_{w \sim\mathcal{P}} \mathbb{E}_{q \sim\pi_{\theta}^{Q}(\cdot\mid w)} r^{Q}(q) + \mathbb{E}_{q \in Q,\, y \sim\pi_{\theta}^{S}(\cdot\mid v_{q},q)} r^{S}(y,q), \tag*{(1)}

where instance ww is drawn by the curriculum (§ 3.3), Q\mathcal{Q} holds the questions that train the Solver, namely the compiled canonical question of each drawn instance, at most one proposal per instance, and replayed bank questions (§ 3.2), and vqv_q is the video of question qq. Questioner reward rQr^{Q} prioritizes valid questions near the limit of the Solver’s current capability, and Solver reward rSr^{S} scores the answer together with how well its cited evidence matches the execution trace. Answered questions enter bank B\mathcal{B} with their pass rates, the fraction of Solver rollouts that answer correctly.

Executable Environments

Executable environments compute labels with the same process that produces the video.

Programs and instances. Library P\mathcal{P} groups programs into environment families ff. Each family defines physical entities, state-transition rules with alternative values, and the tasks it supports. Within a family, an instance ww is set by three quantities: difficulty level ℓ\ell scales entity counts and operation complexity, rule configuration ufu_f selects the active transition behaviors, and playback scale λr\lambda_r sets video duration. Instance parameters xx fix the remaining randomness (Appendix § 8). Given these inputs, program pfp_f executes into trace τ\tau, which compiles into video vv, criteria C\mathcal{C}, and canonical question qˉ\bar{q} (Figure 3):

Figure 3. Environment compilation. Ground truth is recomputed on the sampled frames, and criteria are screened for temporal order. Colors identify entities, blue brackets mark ground-truth intervals, and the dark option is the ground-truth option.

τ=Exec⁡(pf;ℓ,uf,x),(v,C,qˉ)=Compile⁡(τ;a,λr).(2)\tau= \operatorname{Exec}(p_f;\ell,u_f,x), \qquad(v,\mathcal{C},\bar{q}) = \operatorname{Compile}(\tau;a,\lambda_r). \tag*{(2)}

Because vv and C\mathcal{C} come from the same trace, changing ℓ\ell or ufu_f changes the event dynamics and the ground truth together. Compile writes qˉ\bar{q} for the task aa allocated to the instance, using the stem and ground-truth option of the matching criterion and distractors from its domain.

Criteria and tasks. Execution traces yield reliable supervision only when each question is tied to a dynamic event that the policy can see. Each learning target is therefore formalized as criterion c∈Cc \in\mathcal{C}. A criterion specifies a question stem, ground-truth option y∗y^{*}, ground-truth interval ec∗e^{*}_{c} (one or more time segments), and a distractor domain with a minimum resolution floor. An execution label replaces model consensus only if it holds on the frames the policy sees and its answer depends on event order, so each criterion passes two programmatic checks before training.

Frame recomputation. Programs advance state on a fine simulation clock, while the policy observes only frames sampled at a much lower rate, so when an event starts or ends between two sampled frames, a label read from the simulation clock describes a state that no sampled frame shows. We therefore express every temporal label on the timestamps of the sampled frames and recompute each ground-truth value from those frames. A criterion is discarded when its value cannot be recomputed from those frames or disagrees with the simulation (Appendix § 8.§ 3).

Static-question screen. A question whose answer does not depend on the order of events is static. To detect such questions, we recompute each criterion’s answer on the reversed trace and on a trace with permuted events, and we exclude criteria whose answer stays the same under both transformations. When a transformation yields no determinate answer, the screen keeps the criterion, which must still show its target in several sampled frames (Appendix § 8.§ 2).

After both checks, the retained criteria span the tasks in Table 6, such as event count, event order, and state change, grouped into seven task classes. Each family supports a subset of these tasks, and the (family, task) pair (f,a)(f, a) serves as the scheduling unit of the curriculum (§ 3.3).

ClassTasks
IntervalEvent grounding†, state interval†, closest interval†, tile motion interval†, interval relation, interval composition
Event sequenceEvent order, adjacent event, path sequence, pattern extrapolation
Quantity comparisonEvent count, extremum, temporal extremum, rate trend, speed comparison, closest pair, travel rank
MotionMotion direction, relative motion, motion profile, trajectory shape, distance trend
State inferenceForward state, backward state, history query, occluded identity, tile endpoint, tile history, tile waypoint
Container updateSet update, multiset update, sequence update
Numeric computationState change, arithmetic composition, expression evaluation

Table 6. Tasks by class. Tasks marked † are interval questions, answered with a free-form interval; all other tasks are multiple-choice.

Execution-Verified Self-Play

Given compiled instances, self-play needs a validity check for each proposed question and a reward for each answer. Tempo-Zero computes both from the execution trace, so the loop involves no judge model or majority voting (Figure 1a and Figure 2). In each step, the Questioner proposes questions, a programmatic gate filters them, the Solver answers them with timestamped evidence lines, and bank B\mathcal{B} keeps questions for replay (Figure 4).

Figure 4. Execution-verified self-play. The Questioner’s proposal is bound to criterion cqc_q and passes gate g(q)g(q). The Solver’s rollouts give pass rate pp, which sets rlearnr_{\mathrm{learn}} for the Questioner, and only an evidence line that states the criterion’s event earns interval credit.

Question proposals. Each compiled instance already carries its canonical question qˉ\bar{q}, which the Solver answers whether or not any proposal passes the gate. The Questioner asks about the same verified events in new ways: it selects one of the criteria and writes a new stem and distractors, so the policy adapts its questions to the Solver’s current capability while the criterion fixes the ground truth. Because the stem and options are free-form, they can be ambiguous or invalid, or leak the answer. To write a proposal, the Questioner receives the video, the askable criteria in C\mathcal{C} without the timestamps of their events, same-task questions from the bank, and the Solver’s pass rate per criterion (Appendix § 8.§ 4). Its output, a proposal qq, names one criterion c∈Cc \in\mathcal{C} and contains a question stem, the ground-truth option y∗y^* of cqc_q, distractors, and evidence lines citing the events that the criterion depends on. Since its input gives no timestamps, the intervals of these lines are information that the proposal adds, which novelty reward rnovr_{\mathrm{nov}} below scores. Each proposal then passes through a programmatic gate g(q)∈{0,1}g(q) \in\{0, 1\} that checks format, option validity, task scope, and answer leakage in the stem. Option validity requires exactly one option to equal y∗y^* and every distractor to be separated from y∗y^* and from the other distractors by the resolution floor. For accepted proposals, the environment shuffles the options uniformly at random and assigns option letters; proposals with g=0g=0 are not answered.

Question bank. Bank B\mathcal{B} serves three purposes: it supplies same-task examples and pass rates to the Questioner, replay questions to the Solver, and pass-rate statistics to the curriculum (§ 3.3). Among the gated proposals, it preselects at most one per instance, favoring rare task classes and tasks, and stores it with each measured canonical question. At capacity, eviction first removes overrepresented task classes and families, then the oldest measurements, so every task class stays represented.

Answers and evidence. On the Solver side, an answer letter alone does not show whether the Solver located the events that decide it, since multiple-choice answers can often be inferred from isolated frames. The Solver therefore cites its evidence. It receives only the video, the question, and the options, and it answers every question with MM rollouts under πθS\pi_{\theta}^{S}. Across the MM rollouts, pass rate p(q)=s/Mp(q)=s/M, where ss rollouts are correct, measures question difficulty. Rollouts on every gated proposal are scored by the Questioner, and those on canonical questions, preselected proposals, and replayed questions also train the Solver. Each rollout yy contains an answer letter, whose option we denote y^\hat{y}, and LL evidence lines (Ik,dk)(I_k,d_k), each pairing a predicted interval IkI_k with an event statement dkd_k. The evidence lines are scored against the criteria Cq⊆CC_q \subseteq C of question qq, namely the criteria of the events its answer rests on, or cqc_q itself when it rests on none. The program parses the lines with a fixed grammar and assigns them one-to-one to these criteria: line k(c)k(c) is assigned to criterion cc, and δc∈{0,1}\delta_c \in\{0,1\} records whether it states the event of cc, that is, asserts the recorded value of cc about its subject (Appendix § 9.§ 1). With mm matched criteria, evidence score revidr_{\mathrm{evid}} is the statement-level F1F_1 score, with precision m/Lm/L and recall m/∣Cq∣m/|C_q|. Grounded score rgrdr_{\mathrm{grd}} averages the temporal Intersection over Union (IoU) over the criteria and counts only matched lines:

revid=2mL+∣Cq∣,rgrd=mean⁡c∈CqδcIoU⁡(Ik(c),ec∗).(3)r_{\mathrm{evid}} = \frac{2m}{L + |C_q|}, \qquad r_{\mathrm{grd}} = \operatorname{mean}_{c \in C_q} \delta_c \operatorname{IoU}(I_{k(c)}, e_c^*). \tag*{(3)}

A simpler grounding reward, max⁡kIoU⁡(Ik,ec∗)\max_k \operatorname{IoU}(I_k, e_c^*), would credit a broad interval on any line, even one that describes another event (Figure 4); rgrdr_{\mathrm{grd}} instead counts overlap only on the line whose statement matches the criterion, so interval credit requires the correct event.

Reward terms. Both rewards combine these terms and are computed programmatically from the execution trace, the Solver’s rollouts, and the bank:

rS(y,q)=rans+mean⁡(revid,rgrd),rQ(q)=g(q)mean⁡(rlearn,rnov).(4)r^{\mathrm{S}}(y,q) = r_{\mathrm{ans}} + \operatorname{mean}(r_{\mathrm{evid}}, r_{\mathrm{grd}}), \qquad r^{\mathrm{Q}}(q) = g(q)\operatorname{mean}(r_{\mathrm{learn}}, r_{\mathrm{nov}}). \tag*{(4)}

Here rans=1[y^=y∗]r_{\mathrm{ans}} = \mathbf{1}[\hat{y}=y^*] is the answer reward, or IoU⁡(I^,eCq∗)\operatorname{IoU}(\hat{I}, e^*_{C_q}) for interval answer I^\hat{I} when the ground truth is one interval, correct when at least ϵ\epsilon; each term lies in [0,1][0,1], so rS∈[0,2]r^{\mathrm{S}} \in[0,2]. The Solver’s answer and evidence are rewarded separately, so a rollout that cites the correct event earns evidence credit even when its final choice is wrong, while ransr_{\mathrm{ans}} still separates correct from incorrect answers. For the Questioner, gate g(q)g(q) removes the reward of invalid proposals, and learnability reward rlearnr_{\mathrm{learn}} favors questions that the Solver neither always solves nor always misses. It is the variance of a Bernoulli variable whose success probability is the Laplace-smoothed pass rate p~\tilde{p}, scaled to peak at one:

rlearn(q)=4p~(1−p~),p~=s+1M+2.(5)r_{\mathrm{learn}}(q) = 4\tilde{p}(1-\tilde{p}), \qquad\tilde{p} = \frac{s+1}{M+2}. \tag*{(5)}

Smoothing keeps the reward positive when all rollouts are correct or all are wrong. Finally, novelty reward rnov∈[0,1]r_{\mathrm{nov}} \in[0,1] is rgrdr_{\mathrm{grd}} computed on the proposal’s own evidence lines with every interval that the question prints left unscored, so it credits only event times that the Questioner locates in the video (Appendix § 9).

Policy update. Both rewards feed a single joint update of the shared parameters θ\theta. Within step tt, proposals, Solver rollouts, and both rewards are computed under the same snapshot πθt\pi_{\theta_t} and held fixed during the update, so each Questioner reward reflects the current Solver and passes no gradient through its pass rate. The policy is then updated in one Group Relative Policy Optimization (GRPO) step [30] over the groups of both roles. A Solver group holds the MM rollouts of one question, and a Questioner group holds the proposals of one instance. Within each group G\mathcal{G}, the advantage of sample ii is its mean-centered reward, A^i=ri−rˉG\hat{A}_i = r_i - \bar{r}_{\mathcal{G}}, where rˉG\bar{r}_{\mathcal{G}} is the mean reward of G\mathcal{G}. Groups whose rewards are all equal carry no advantage and are omitted from the update.

Environment Evolution

Fixed programs freeze the task allocation, difficulty, and event dynamics of training (Figure 1b). As the policy improves, more Solver groups agree, so the answer reward no longer separates their rollouts. Tempo-Zero therefore changes the environments in two ways (Figure 5): the curriculum reallocates instances across (family, task) pairs and levels by pass rate, and the policy selects rule changes that the executor validates.

Figure 5. Environment evolution. Pass rates guide allocation ωf,a\omega_{f,a} (Eq. (6)) and set level ℓ\ell, and the policy selects a rule change, which the executor validates before deployment.

Task allocation. Uniform instance sampling spends updates on tasks that the policy already solves or cannot yet solve. To avoid this, the curriculum reads exponentially decayed pass-rate statistics in bank B\mathcal{B} after each round and fixes the allocation and levels of the next round. Each family receives an equal share of instances, and within family ff, pair (f,a)(f,a) receives

wf,a=κnf+(1−κ)wf,a∑a′wf,a′.(6)w_{f,a} = \frac{\kappa}{n_f} + (1-\kappa)\frac{w_{f,a}}{\sum_{a'} w_{f,a'}}. \tag*{(6)}

where coverage share κ\kappa spreads part of the quota evenly over the nfn_f tasks of ff so that every task stays measured, and the policy sets task weight wf,aw_{f,a} per class, times a fixed task tilt. The same statistics move difficulty: a pair’s level ℓ\ell rises when its decayed pass rate reaches padvp_{\mathrm{adv}} and falls at pretp_{\mathrm{ret}}.

Rule selection. Allocation redistributes the existing environments but cannot create new event dynamics, which requires changing the rules. Rules decide which dynamics a family can produce, and Tempo-Zero lets the policy choose how they change. After each round except the last, the environment runtime composes a rule menu for every family. The menu lists the current configuration and alternatives that each move one rule, or in later rounds a pair of rules, to values the family has not run. The policy reads the family’s pass rates and recorded responses under the current configuration, sets the class weights in wf,aw_{f,a} of Eq. (6), and either keeps ufu_f or selects a menu entry, optionally, for Shell game, with operation-graph edits (Appendix § 8.§ 5). Before deployment, the executor checks each selected change for validity and re-executes the program to preview the resulting videos and criteria; an invalid change keeps the previous program. Rule selection runs at inference and receives no gradient update. Independently of rule selection, playback scale λr\lambda_r follows a fixed schedule that lengthens videos across rounds rr. Algorithm 1 in Appendix § 6.§ 1 summarizes the full training loop.

Experiments

We test whether execution-verified self-play improves real-video grounding, long-video understanding, video reasoning, and other architectures.

Experimental Setup

Models and training. We train Qwen3-VL-4B-Instruct and Qwen3-VL-8B-Instruct [1], each serving as both Questioner and Solver, with LoRA adapters for five rounds on videos rendered by the executable environments alone, without external videos, human annotations, or supervised fine-tuning (Appendix § 6). Baselines are the instruction-tuned base model and three self-improvement methods: VisPlay [10] and V-Zero [32], which train on images, and Video-Zero [42], which trains on recorded videos; all results follow the evaluation protocol of Zhang et al. [42].

Benchmarks. The final checkpoint is evaluated zero-shot on twelve real-world benchmarks in three groups. Temporal grounding uses ANet-RTL [14], ActivityNet Captions [19], Charades-STA [8], and NExT-

[38] scored by mean IoU (mIoU), recall at IoU thresholds ([email protected]/0.5/0.7), and grounded QA accuracy ([email protected]/0.5). Long-video understanding uses LongVideoBench [37], MLVU [45], Video-MME-Long [7], and LSDBench [28], and video reasoning uses LongVideoReason [4], MMVU [44], VideoMathQA [29], and VideoMMMU [12], both scored by accuracy (Appendix § 6.§ 4).

Main Results

Temporal grounding. Tempo-Zero improves every grounding metric over the base model at 4B and 8B and gives the best result in 26 of their 28 metrics in Table 1. The margin over Video-Zero widens at 8B: on Charades-STA, Video-Zero gains 0.64 mIoU over the base model and Tempo-Zero gains 9.40. Video-Zero derives the temporal evidence it rewards from the model’s own predictions, whereas Tempo-Zero scores evidence lines against intervals computed by execution, which stay exact at any model scale (Eq. (3)). Training never sees a real-world interval annotation, so these gains reflect localization transferred from rendered to real videos.

MethodANet-RTL mIoU[email protected][email protected][email protected]ActivityNet Captions mIoU[email protected][email protected][email protected]Charades-STA mIoU[email protected][email protected][email protected]NExT-GQA [email protected][email protected]Avg.
Base model16.8622.7015.728.7322.8630.9419.0411.2937.5258.9036.1216.2323.0915.4025.08
VisPlay16.5823.1413.978.7322.8930.9819.1211.3137.5958.8236.5916.4223.1415.3325.05
V-Zero15.8520.9613.978.3022.8130.9118.9211.3137.1058.3335.2415.6222.8215.2224.64
Video-Zero29.7544.9828.8213.5432.1244.7627.6716.2441.8565.1140.8120.0338.2923.0035.50
Tempo-Zero31.34 ↑ 14.4848.03 ↑ 25.3331.00 ↑ 15.2813.10 ↑ 4.3734.98 ↑ 12.1249.35 ↑ 18.4131.04 ↑ 12.0017.26 ↑ 5.9742.53 ↑ 5.0166.29 ↑ 7.3941.26 ↑ 5.1419.49 ↑ 3.2639.17 ↑ 16.0824.50 ↑ 9.1037.00 ↑ 11.92
Base model21.9530.5721.8310.0426.5636.5922.6312.8536.7059.1133.8713.4935.9321.8330.28
VisPlay21.8332.3120.0910.0426.7436.9422.9912.9336.6559.0333.9213.4735.8722.1930.27
V-Zero22.7732.3120.529.1726.6936.7923.0513.0036.4358.6333.6613.4135.7322.1130.40
Video-Zero26.1939.3024.4512.2329.8741.7726.2314.6637.3460.1635.5413.5839.6024.2633.25
Tempo-Zero31.22 ↑ 9.2746.72 ↑ 16.1528.38 ↑ 6.5513.54 ↑ 3.5034.16 ↑ 7.6049.20 ↑ 12.6130.86 ↑ 8.2316.26 ↑ 3.4146.10 ↑ 9.4072.26 ↑ 13.1549.81 ↑ 15.9423.06 ↑ 9.5740.39 ↑ 4.4625.14 ↑ 3.3137.97 ↑ 7.69
Base model23.4532.7523.1413.1027.9037.6523.9814.3947.3468.4451.6130.1338.8323.6334.38
Tempo-Zero34.23 ↑ 10.7849.78 ↑ 17.0333.62 ↑ 10.4817.90 ↑ 4.8036.35 ↑ 8.4552.42 ↑ 14.7732.95 ↑ 8.9717.38 ↑ 2.9948.77 ↑ 1.4377.15 ↑ 8.7152.96 ↑ 1.3522.37 ↓ 7.7645.15 ↑ 6.3227.88 ↑ 4.2541.12 ↑ 6.74
Base model23.9734.9322.2710.0418.6424.9314.657.0519.0827.3913.046.0521.7210.9920.85
Tempo-Zero30.52 ↑ 6.5541.48 ↑ 6.5527.51 ↑ 5.2415.72 ↑ 5.6833.53 ↑ 14.8947.52 ↑ 22.5929.94 ↑ 15.2915.99 ↑ 8.9432.01 ↑ 12.9350.97 ↑ 23.5824.30 ↑ 11.269.52 ↑ 3.4726.40 ↑ 4.6814.64 ↑ 3.6530.61 ↑ 9.76

Table 1. Temporal grounding on real-world benchmarks. Metrics in %; Avg. averages the mIoU of the first three benchmarks and [email protected]. Bold marks the best per column within each backbone, and underline marks the second best at 4B and 8B, where all methods are evaluated; arrows give the change over the base model, the only comparison at 30B-A3B and Gemma.

Long-video understanding and video reasoning. The gains extend beyond grounding: Tempo-Zero improves all eight benchmarks of Table 2 on every Qwen3-VL backbone and gives the best result in 13 of the 16 metrics at 4B and 8B. Because the training videos contain only simple rendered entities, these results indicate that the temporal skills learned from execution carry over to real-world content.

ModelMethodLongVideoBenchMLVUVideo-MME-LongLSDBenchLongVideoReasonMMVUVideoMathQAVideoMMMUAvg.
4BBase model57.7062.6051.6054.6869.9064.3219.0557.5654.68
4BVisPlay59.2063.5053.2054.8369.6063.3618.3357.4454.93
4BV-Zero59.5063.5051.9054.6868.2064.4820.9558.3355.19
4BVideo-Zero59.1063.4053.6056.5270.3064.9621.6761.5656.39
4BTempo-Zero61.00 ↑ 3.3067.36 ↑ 4.7653.30 ↑ 1.7056.06 ↑ 1.3872.40 ↑ 2.5066.08 ↑ 1.7622.38 ↑ 3.3363.11 ↑ 5.5557.71 ↑ 3.03
8BBase model59.8064.4055.7057.5968.6068.3223.8163.7857.75
8BVisPlay60.5064.9054.9057.4468.1067.0421.4362.6757.12
8BV-Zero60.1064.2056.0056.9069.2068.8022.1463.2257.57
8BVideo-Zero60.4064.6056.6056.7570.7068.0025.4864.2258.34
8BTempo-Zero61.00 ↑ 1.2068.51 ↑ 4.1156.90 ↑ 1.2058.59 ↑ 1.0073.00 ↑ 4.4068.48 ↑ 0.1627.38 ↑ 3.5764.44 ↑ 0.6659.79 ↑ 2.04
30B-A3BBase model65.3770.2658.3362.5071.4072.1626.9065.1161.50
30B-A3BTempo-Zero66.70 ↑ 1.3371.34 ↑ 1.0860.56 ↑ 2.2363.96 ↑ 1.4675.60 ↑ 4.2073.60 ↑ 1.4431.90 ↑ 5.0067.44 ↑ 2.3363.89 ↑ 2.39
GemmaBase model50.7154.5146.4447.0970.6065.2830.0065.8953.81
GemmaTempo-Zero53.40 ↑ 2.6954.62 ↑ 0.1148.00 ↑ 1.5655.14 ↑ 8.0571.10 ↑ 0.5067.04 ↑ 1.7629.29 ↓ 0.7166.11 ↑ 0.2255.59 ↑ 1.78

Table 2. Long-video understanding and video reasoning. Official accuracy in %; marks as in Table 1.

Other backbones. To test whether the recipe depends on the dense Qwen3-VL backbones, we also train Qwen3-VL-30B-A3B-Instruct, a sparse mixture-of-experts model with 3B active parameters, and Gemma 4 E4B 9 from another model family. In the last two blocks of Table 1 and Table 2, Tempo-Zero raises 21 of the 22 metrics at 30B-A3B and 21 on Gemma, so its gains rely on neither a dense architecture nor one model family.

Ablations

All ablations use Qwen3-VL-4B and remove one component under the same setup (Appendix § 11.§ 1); the full method is best in every column.

Questioner. The Questioner supplies questions and targets them. W/o Questioner trains the Solver only on the canonical questions that the programs compile, and Overall falls from 50.81 to 47.71, the largest Overall drop. Proposals ask new questions about the verified criteria of the same instances, whose ground truth stays fixed, so they widen the training distribution without adding label noise. Targeting comes from the two terms of rQr^{Q}, of which learnability matters more: w/o learnability reward lowers Temporal Grounding by 1.75 points, more than three times the drop of w/o novelty reward. Questions at intermediate pass rates yield Solver groups whose rollouts disagree, so the answer reward separates them, whereas novelty only spreads proposals over task signatures.

Solver. Evidence terms teach the Solver to locate events. With answer reward only, rS=ransr^{S}=r_{\mathrm{ans}} and evidence lines earn no reward, so Temporal Grounding falls by 5.70 points, the largest drop in its column. Of the two evidence terms, the statement check carries most of this signal. W/o evidence score leaves a correct statement credited only through the interval overlap of rgrdr_{\mathrm{grd}} and lowers Temporal Grounding by 1.66 points, over four times the drop of w/o grounded score, whose interval credit refines the statement check. The benefit reaches beyond grounding, since Video QA & Reasoning also drops the most among the Solver variants when only the answer is rewarded.

VariantTemporal GroundingVideo QA & ReasoningOverall
Questioner
  w/o novelty reward36.5356.8850.10
  w/o learnability reward35.2557.2749.93
  w/o Questioner31.8655.6347.71
Solver
  w/o evidence score35.3457.3350.00
  w/o grounded score36.6357.1150.28
  Answer reward only31.3056.2847.96
Environment evolution
  w/o rule selection35.2356.5849.46
Tempo-Zero (full)37.0057.7150.81

Table 3. Ablations on Qwen3-VL-4B. Temporal Grounding and Video QA & Reasoning are the Avg. columns of Table 1 and Table 2, and Overall averages all twelve benchmarks; marks as in Table 1.

Environment evolution. Evolution changes which instances are drawn and what happens in them, and w/o rule selection removes only the second: it keeps the initial rules, while the curriculum still reallocates instances and the playback schedule still lengthens videos. Rule changes add event dynamics that reallocation over fixed rules does not supply: without them, Temporal Grounding drops by 1.77 points.

Analysis

Training dynamics. Trained on execution-grounded rewards, both roles improve over the rounds of the 4B and 8B runs (Appendix § 10). On 128 held-out instances (Appendix § 10.§ 2), Solver accuracy rises from 25.9% to 42.8% at 8B, and the evidence score nearly doubles at 4B, from 24.3% to 47.0% (Figure 6A–B). The share of Questioner proposals that pass the gate rises from 80.7% to 94.9% at 4B and stays above 91% at 8B (Figure 6C), so the policy learns the gate’s validity checks. Rule selection is most active early: the policy changes rules in 56 of its 96 family decisions, most of them for rounds 2 and 3 (Figure 6D), and every change stays verifiable, since all menu alternatives compile into instances with recomputed criteria (Appendix § 10.§ 3).

Figure 6. Training dynamics. (A) Held-out accuracy. (B) Evidence (filled) and grounded (hollow) scores; B is the base model. (C) Proposals passing the gate. (D) Families whose rules change for each round.

Execution labels versus majority voting. These gains rest on execution labels, which can replace consensus only if they hold on the frames that the policy sees, as the checks confirm: recomputation discards fewer than 1% of the compiled criteria (Appendix § 8.§ 3), and every Solver group is scored against a criterion that passed both checks, so its label matches the sampled frames (Appendix § 10.§ 1). Majority voting, a labeling rule of prior video self-play, would assign a wrong label to 52.5% of 7,420 Solver groups (Figure 7A). In 26.3% of all groups a rollout chooses the correct option but loses the vote, as in Figure 1a, and in 14.8% all eight rollouts agree on a wrong option, which agreement filtering would keep. The wrong-label share is 56.8% at 4B and 48.2% at 8B, so consensus labels would mislabel about half of the training questions at both scales. Evidence credit shows the same contrast: about half of the rollouts that the content-blind overlap max⁡kIoU⁡(Ik,e⋆)\max_k \operatorname{IoU}(I_k,e^\star) would credit earn it only on lines that state another event, and rgrdr_{\mathrm{grd}} withholds that credit (Figure 7B).

Figure 7. Execution labels. (A) Majority vote versus execution labels on 7,420 Solver groups (%). (B) Rollouts credited only on wrong-event lines, and credit kept by rgrdr_{\mathrm{grd}} (%).

Training value of evolved environments. Whether the event dynamics that rule selection adds also yield better training data can be tested apart from the training loop, by fine-tuning the 4B base model on the banks of each run (Table 4; Appendix § 11.§ 2). Both sources improve over the base model in all columns, so execution-labeled data transfer to real videos even outside the self-play loop. Data from the evolved rules score higher in every column, so the data produced under rule selection transfer better.

Training dataTemporal GroundingVideo QA & ReasoningOverall
Base model25.0854.6844.81
Initial rules30.7356.7148.05
Evolved rules31.7857.0948.65

Table 4. Supervised fine-tuning on bank data. The 4B base model fine-tuned for one epoch on the banks of runs without or with rule selection.

Conclusion

We presented Tempo-Zero, a self-improvement framework that grounds video self-play in an executable program library, whose programs render synthetic videos together with ground-truth options and intervals, so supervision stays verifiable without external video corpora or majority voting. A single policy acts as both Questioner and Solver and is trained on execution-grounded rewards, while a curriculum allocates tasks by pass rate and the policy selects rule changes. Trained only on simple programs, without external video data or supervised fine-tuning, Tempo-Zero outperforms base models and recent self-play baselines on average across twelve real-world benchmarks at different model scales, especially in temporal grounding.

Ethics Statement

All training videos are rendered from synthetic programs, so training uses no human subjects, personal data, or scraped video. Evaluation uses twelve public benchmarks under their released protocols. Appendix § 13 discusses limitations and broader impact.

Reproducibility Statement

Algorithm 1 in Appendix § 6.§ 1 gives the self-play loop, and Table 5 lists the training configuration shared by the 4B, 8B, 30B-A3B, and Gemma models. Appendices § 6.§ 3 and § 6.§ 4 describe compute and the evaluation protocol. Appendix § 8 specifies the twelve environment families, frame sampling, and the input and output protocols of both roles, and Appendix § 9 defines the rewards, the question bank, and the optimization. Appendix § 11 defines the ablation variants, and Appendix § 12 lists the prompts together with a Solver response. Code will be made publicly available.

ComponentSetting
BackboneQwen3-VL-4B/8B/30B-A3B-Instruct and Gemma-4-E4B-it; LoRA with rank 64 and α=128\alpha= 128 on the q/k/v/o projections of the language model; the vision tower and the A3B experts carry no adapter
Environments12 environment families, 3 difficulty levels; 5 rounds of 20 steps
Batch32 instances per step; playback scale λr=1.0,1.25,1.5,1.75,2.0\lambda_r = 1.0, 1.25, 1.5, 1.75, 2.0 for rounds r=1,…,5r = 1, \ldots, 5
Questioner4 proposals per instance; one to three located evidence lines
SolverM=8M = 8 rollouts per question; one to eight evidence lines; criteria are those of the events the target rests on, or the target itself when it rests on none; at most 72 groups per step (32 canonical, up to 32 preselected proposals, 8 replayed)
Question bankCapacity 640, shared across rounds; up to 8 replayed questions per step; at most one preselected proposal per instance; one prior example in the Questioner prompt
Option countCycles across (6, 6, 6, 5, 4)
CurriculumCoverage share κ=0.30\kappa= 0.30; pass-rate decay 0.90 per step; level thresholds ρadv=0.80\rho_{\mathrm{adv}} = 0.80 and ρret=0.20\rho_{\mathrm{ret}} = 0.20 on the decayed pass rate, applied with at least 3 questions; class weights start equal and change by at most a factor of 2 per round
Rule menuAt most 3 alternative configurations besides keep; one selection per family per round
OptimizerAdamW, learning rate 5×10−55 \times10^{-5}, weight decay 10−210^{-2}
ScheduleConstant learning rate without warmup; single PPO epoch per step; one combined update over both roles, 100 updates per run
RegularizationLow-variance KL with coefficient βKL=10−3\beta_{\mathrm{KL}} = 10^{-3} against the base model with adapters disabled; clipping threshold 0.2; gradient norm cap 0.5; advantages mean-centered without standard-deviation normalization
Precisionfp32 master weights; bf16 compute and rollout
SamplingTemperature 1.0; top-p 0.99; unrestricted top-kk
Token limits16,384 prompt tokens; 2,048 response tokens; context ceiling 24,576
Visual inputUniform sampling at 2 fps, 4 to 64 frames, so clips longer than 32 s fall below 2 fps; 3,136 to 100,352 pixels per frame
CheckpointingSaved after every round (every 20 steps)
Holdout128 synthetic instances, evaluated before training and after every round; used for neither training nor curriculum
Hardware8 GPUs per run

Table 5. Training configuration. Settings shared by the 4B, 8B, 30B-A3B, and Gemma configurations.

AI Use Statement

We used generative AI tools to draft and edit the paper text, to format references, tables, and figures, and to create and edit software code. The authors reviewed all AI-assisted text and code and take responsibility for the full content of this work, including text, claims, and artifacts produced with the aid of generative AI.

Training Configuration and Evaluation

Self-Play Algorithm

Algorithm 1 outlines the training loop of the shared vision-language policy. BATCH draws the next batch from the allocation that the curriculum of § 3.3 fixes for the round (Eq. (6)) and renders it ahead of the step that uses it. The bank stores every measured canonical question and at most one gated proposal per instance, preselected by task-class and task rarity. At capacity, eviction first reduces overrepresented task classes and families and then removes the oldest measurements (Appendix § 9.§ 2). A single AdamW optimizer state persists across both roles and across rounds.

Algorithm 1 Tempo-Zero training loop

Require: policy πθ\pi_\theta, frozen reference policy πref\pi_{\mathrm{ref}}, program library P\mathcal{P}, empty bank B\mathcal{B}

  1. for round r=1,…,Rr = 1, \ldots, R with playback scale λr\lambda_r do

  2. fix the allocation ωf,a\omega_{f,a} of round rr Eq. (6)

  3. for each step tt do

  4. W←\mathcal{W} \leftarrow BATCH: next batch of the round’s allocation, screened and rendered

  5. sample proposals q∼πθQ(⋅∣w)q \sim\pi_{\theta}^{\mathrm{Q}}(\cdot\mid w) for each w∈Ww \in\mathcal{W}; compute gate g(q)g(q)

  6. Q^←\widehat{\mathcal{Q}} \leftarrow gated proposals, at most one per instance, preselected by class and task rarity

  7. Q←{qˉw}w∈W∪Q^∪\mathcal{Q} \leftarrow\{\bar{q}_w\}_{w \in\mathcal{W}} \cup\widehat{\mathcal{Q}} \cup questions replayed from B\mathcal{B}

  8. sample MM rollouts y∼πθS(⋅∣v,q)y \sim\pi_{\theta}^{\mathrm{S}}(\cdot\mid v,q) for each gated proposal and each q∈Qq \in\mathcal{Q}; compute p(q)p(q)

  9. compute rQr^{\mathrm{Q}} for all proposals and rSr^{\mathrm{S}} for rollouts on Q\mathcal{Q} Eqs. (3)–(5)

  10. record measured canonical questions and Q^\widehat{\mathcal{Q}} in B\mathcal{B}; evict overrepresented task classes and families, then the oldest

  11. mean-center rewards within each group; omit groups whose rewards are all equal

  12. θt+1←\theta_{t+1} \leftarrow one GRPO update on Solver groups over Q\mathcal{Q} and Questioner groups per instance

  13. end for

  14. if r<Rr < R then

  15. move each pair’s level by its decayed pass rate in B\mathcal{B}

  16. for each family, the policy sets class weights in wf,aw_{f,a} and keeps ufu_f or selects a rule change from its menu

  17. the executor validates and previews each change; an invalid change keeps the previous program

  18. end if

  19. end for

  20. return πθ\pi_\theta

Training Configuration

Table 5 lists the settings shared by the 4B, 8B, 30B-A3B, and Gemma configurations. The Questioner and Solver contribute separate reward groups to one combined update of the LoRA adapters on the language model, and rule selection after each round runs at inference only. The instruction-tuned checkpoint, obtained by disabling the adapters, serves as the reference policy for KL regularization.

The scheduled budget comprises 3,200 instances and at most 12,800 Questioner proposals. Every canonical question, gated proposal, and replayed question is answered eight times (M=8M = 8) under the policy snapshot that generated the proposals. These responses give every gated proposal its pass rate for the Questioner reward, and the responses to canonical questions, preselected proposals, and replayed questions also train the Solver. Groups whose rewards do not differ supply pass rates but no gradient, and both roles are scored before the shared parameters change.

Compute Resources

Each training run uses eight GPUs. A single persistent inference engine serves rollouts for both roles, while video rendering runs asynchronously in a CPU worker pool scheduled one step ahead of the policy update.

Evaluation Protocol

Benchmark suites. Video reasoning is evaluated on LongVideoReason [4], MMVU [44], VideoMathQA [29], and VideoMMMU [12], scored by question-answering accuracy (%). Temporal grounding is evaluated on ANet-RTL [14], ActivityNet Captions [19], Charades-STA [8], and NExT-GQA [38]. The first three report mean Intersection over Union (mIoU) between predicted and ground-truth intervals together with recall at IoU thresholds 0.3, 0.5, and 0.7, and NExT-GQA reports grounded accuracy at IoU 0.3 and 0.5, which requires both a correct answer and temporal overlap. Long-video understanding is evaluated on LongVideoBench [37], MLVU [45], Video-MME-Long [7], and LSDBench [28], which probe visual context over extended durations and are scored by question-answering accuracy (%).

Final evaluation. Final numbers use the checkpoint from the fifth training round on the complete test splits of all twelve benchmarks. All models, including the baselines and ablation variants, are evaluated under the same protocol, which follows Zhang et al. [42] and the official metrics of each benchmark.

Executable Environments and Interfaces

Environment Coverage and Design

Table 6 lists the tasks by class, and Table 7 summarizes the program library. Each environment family implements a deterministic state-transition system, rendering routines, query templates, and analytical verification routines. Difficulty levels govern the number of interacting entities and the operation complexity, while the playback scale sets the temporal duration. Levels enter in rotation and thereafter follow the curriculum, and option counts cycle over a fixed sequence. Figure 8 shows state transitions from three representative families.

FamilyObservable dynamicsReasoning targets
BilliardsKinematic motion, elastic contact, and velocity shiftsTrajectory direction, event order, state transitions
Block stackingSequential placement and physical supportObject counts, stacking order, spatial relations
Checkout queueArrival, service progression, and departureQueue duration, entity counts, interval relations
DominoesCascading propagation along contact dependenciesChain continuation, trigger ordering, collapse speed
Ferris wheelCoupled rotating structures and cyclic cabinsRelative angular rates, phase shifts, event timing
Filling glassesLiquid level shifts and volumetric transfersContinuous quantities, extrema, volume change intervals
Maze runDiscrete path progression and visited markersRoute reconstruction, intersection counts, milestone order
Parking lotVehicle ingress, stall occupancy, and egressOccupancy states, dwell durations, interval intersections
Shell gameContinuous occlusion, permutations, and transfersObject tracking, identity recovery, hidden states
Tag spreadContact-induced state propagation across agentsInfection ordering, transmission delays, final states
Traffic lightsPeriodic signal phases and permitted trajectoriesPhase duration counts, rule compliance, interval localization
Tunnel trainsMotion across visible and occluded segmentsTransit speed, occluded intervals, exit order

Table 7. Twelve environment families. Each family supports three difficulty levels; the columns summarize its observable dynamics and the reasoning targets it supports.

Figure 8. Executable environments. Rendered frame pairs from Dominoes, Filling glasses, and Traffic lights; the labels inside the frames are part of the rendered video.

Video Frame Sampling and Temporal Coordinates

Frames are sampled uniformly over the video at a fixed target rate up to a fixed maximum count, always including the initial and final states. A criterion’s target must be visible in at least three sampled frames. Every ground-truth value is recomputed from the sampled frames, and a criterion is discarded when its value cannot be recomputed from those frames or disagrees with the simulation. The static-question screen records three outcomes: changed under an evaluable transformation, unchanged under both evaluable transformations, or undetermined. The second outcome is excluded, and undetermined criteria remain subject to the normal visibility and validity checks. A transformation cannot be evaluated when reversal creates tied events or leaves the query’s supported domain. Criteria of tasks that declare every operation they depend on, such as set update and expression evaluation, are recorded as undetermined without running the transformations, because each of those operations is already recomputed from the sampled frames.

All ground-truth temporal labels use the effective time coordinate exposed to the model. For FF selected frames spanning the rendered video duration dd, which playback scale λr\lambda_r stretches, the observation manifest defines

flabel=F−1d,ti=iflabel,i=0,…,F−1.(7)f_{\mathrm{label}} = \frac{F-1}{d}, \qquad t_i = \frac{i}{f_{\mathrm{label}}}, \quad i=0,\ldots,F-1. \tag*{(7)}

The input processor consumes this effective frame rate and the selected frames directly, without a second temporal downsampling, so verification intervals map to the same discrete timestamps that the model sees.

Verification Checks on the Training Environments

To measure how often the two checks of § 3.1 apply, we read the check records of the 5,074 distinct instances that the three Qwen3-VL training runs draw from the twelve families, 2,599 at level 0, 1,179 at level 1, and 1,296 at level 2. A level-2 video holds 22 key events over 119 seconds on average, against 12 over 36 seconds at level 0 (Figure 9A). Frames are selected uniformly over each video, independently of where events occur, at no more than 2 fps and 64 frames per video. A level-0 video thus has 58.1 frames on average at an effective rate of 1.69 fps, and a level-2 video 64.0 frames at 0.62 fps (Eq. (7)). Table 8 shows that the share of recorded events that start and end between two sampled frames grows from 2.82% at level 0 to 28.56% at level 2. A label read from the simulation clock would therefore often describe a state that no sampled frame shows.

Figure 9. Training environments. (A) Key events and duration by level. (B) Static-question screen classes in %; only invariant criteria are removed.

LevelInstancesCountfpsbetweenCriteriaDisagreeUnverifiedOrderedInvariantUndet.
02,59958.11.692.8225,338232567.9310.7621.31
11,17963.81.0010.0211,623444474.337.2918.38
21,29664.00.6228.5612,56414112676.217.0216.77
Overall5,07460.91.2616.6049,52520819571.519.0119.49

Table 8. Verification checks on the training environments. Instances per level, mean sampled frames and effective frame rate, share in % of recorded events that fall between two sampled frames, criteria compiled and discarded by the recomputation, and shares in % of the static-question screen classes among the criteria that pass the recomputation. Invariant criteria are removed, and ordered and undetermined criteria are kept.

Two parts of the environment prevent this. First, the key events that questions refer to are limited to events that at least one sampled frame shows and that lie at least two sampled frames apart, and an instance must keep at least 3, 5, or 7 such events at levels 0, 1, and 2. Every one of the 82,392 key events in these instances therefore appears on a sampled frame. Second, the recomputation discards 403 of the 49,525 compiled criteria: in 208 the recomputed value disagrees with the simulation, and 195 cannot be recomputed from the frames. Disagreements concentrate in Event count and Extremum, with 110 and 68 criteria, and the most frequent case counts three events on the simulation clock, of which the sampled frames show two. The discarded share grows from 0.19% at level 0 to 2.13% at level 2, as the share of events between frames does.

The static-question screen removes only 9.01% of the remaining 49,122 criteria, those whose answer stays the same under both reversal and permutation (Figure 9B). Nearly all criteria of Event grounding, Event order, and State interval pass the screen, with at most 0.13% removed. The removed criteria come mainly from Extremum and Event count, where 35.69% and 34.04% of each task’s criteria keep the same answer under both transformations, since many counts and comparisons do not depend on event order.

Role Inputs and Output Protocols

The Questioner receives the rendered frames, the scene description and active rules from the execution metadata, the askable criteria with their ground-truth options and distractor domains, one question of the same task from the bank, and the Solver’s pass rate per criterion. No timestamp of an event that a criterion rests on is shown, so the Questioner reads the intervals of its located lines from the frames, and novelty reward rnovr_{\mathrm{nov}} checks them (Appendix § 9.§ 1). Each criterion specifies a target entity and the relation evaluated on it, a question stem, the ground-truth option, the ground-truth interval, and a distractor domain with a resolution floor. The Solver receives only the frames, the question text, and, for a multiple-choice question, the options.

When proposing, the Questioner names one verified criterion, writes the stem and the options, and cites the events the criterion depends on as located evidence lines before its answer payload. The gate accepts a proposal only if exactly one option equals the ground-truth option y∗y^* and all distractors lie in the criterion’s domain, separated at the declared temporal or numerical resolution. The stem must also match the task specification, name the criterion’s subjects, keep its qualifiers, state no ground-truth value, and end in a single question mark. The environment runtime then determines the final option permutation and the answer letter. Criteria without enough distinct distractors are excluded from the askable set, and the Questioner’s located lines are never shown to the Solver.

The Solver is prompted to write located evidence lines, then derivation lines without intervals, and finally a single option character inside <answer>, or for an interval question the start and end seconds of the interval as JSON. Each evidence line starts with a list of [start, end] pairs in decimal seconds, followed by one observed event or state; a recurring identical event or state places all of its intervals in that one list. Static in-context demonstrations define these output structures (Appendix § 12).

Rule Selection and Execution Determinism

After each round except the last, the environment runtime composes for every family a menu of at most three alternative rule configurations besides the current one. Each entry moves one rule to a value the family has not run, and from the third round on, entries that move a pair of rules lead the menu. The policy receives the menu with a preview of each entry, the rule meanings, the current executable graph, the editable schema, the current class weights, prior changes, and measurements under the current configuration and playback. scale. Canonical and Questioner measurements remain separate, and recorded responses and evidence scores are provided as feedback. The output selects a menu entry and sets the class weights of the family, which enter wf,aw_{f,a}; Shell game additionally supports operation-list, dependency, and operation-parameter edits of its operation graph. Each weight changes by at most a factor of two per round, and only for classes with at least three current-configuration questions. The interface permits neither arbitrary program rewriting nor independent changes to ground truth. The executor checks field validity, parameter domains, references, finite expansion, and acyclicity, and a joint preview executes the proposed configuration and graph together before rendering and recompiling the resulting supervision. Invalid or failed outputs keep the previous program. Task levels move by the pass-rate thresholds of § 3.3 and class weights by the policy’s bounded selection. A task that produced no instance in a round although at least three were requested steps down one level. Interval tasks instead alternate between two tiers, level 0 at playback scale 1.0 and level 2 at playback scale 2.0, and the state-tracking tasks, namely set, multiset, and sequence update, occluded identity, history query, and expression evaluation, take levels 0 and 1 in the first 20 steps, levels 1 and 2 in the next 20 steps, and level 2 afterward. Task weight wf,aw_{f,a} is the class weight of aa times a fixed tilt of 2.6 for interval tasks, 4.0 for state-tracking tasks, 0 for tile endpoint, tile waypoint, tile history, and forward state, and 1 otherwise, and every task keeps at least 4 percent of its family’s instances.

Selected configurations and program graphs determine future traces, renderings, criteria, and answers. Instance records preserve the original generation context: replay resolves the saved instance identifier through its frame manifest and keeps the question’s original scoring context, so later environment edits do not alter earlier questions. The curriculum constants, namely the pass-rate decay, the coverage share κ\kappa, the level thresholds and their minimum question count, and the weight bound, are fixed across runs (Table 5).

Example of a rule change. Figure 10 shows one rule change in Billiards with the seed and level held fixed. Changing the side cushion from specular to retroreflective reflection sends the pink ball back along its incoming path. The canonical question, “Which table quadrants does the pink ball enter on its first 12 quadrant changes, in order?”, stays the same, but re-execution changes its ground-truth option from “lower-left, upper-left, upper-right, lower-right” repeated three times to “lower-left, lower-right, upper-right, lower-right” repeated three times, together with the 12 ground-truth intervals. The sampled frames coincide up to 4.0 s and differ from 7.9 s on, so the new rule yields new event dynamics whose labels remain exact.

Figure 10. A rule change in Billiards. Frames at 0.0, 4.0, 7.9, 11.9, 15.9, and 19.8 s of the same instance before and after the rule change; the overlays are part of the rendered frames.

Rewards, Question Bank, and Optimization

Reward Terms

This section details the reward terms of Eq. (4).

Learnability. Let ss of the MM Solver rollouts on question qq be correct, where an interval answer is correct when its IoU with ecq∗e^{*}_{cq} is at least ϵ=0.5\epsilon= 0.5. With pass rate p=s/Mp = s/M as the estimated probability that one rollout is correct, the Bernoulli variance p(1−p)p(1-p) peaks at p=1/2p=1/2 and vanishes when all rollouts are correct or all are wrong. Laplace smoothing replaces pp by p~=(s+1)/(M+2)\tilde{p}=(s+1)/(M+2), and the learnability reward

rlearn(q)=4p~(1−p~)=4(s+1)(M−s+1)(M+2)2(8)r_{\mathrm{learn}}(q)=4\tilde{p}(1-\tilde{p})=\frac{4(s+1)(M-s+1)}{(M+2)^2} \tag*{(8)}

equals one at s=M/2s=M/2 and stays positive at s∈{0,M}s\in\{0,M\}. With M=8M=8, it takes the values 0.36, 0.64, 0.84, 0.96, and 1 for s=0,1,2,3,4s=0,1,2,3,4 and is symmetric around s=4s=4.

Evidence matching. The Solver’s evidence lines are parsed with the grammar of Appendix § 8.§ 4. Each line is assigned to at most one criterion of CqC_q and each criterion to at most one line, so that the assignment is one-to-one; k(c)k(c) denotes the line assigned to criterion cc. Among such assignments, the one with the most matched criteria, and then the highest grounded score defined below, is kept. The indicator δc\delta_c equals one when the assigned line states the event of cc and zero otherwise; a criterion without an assigned line has δc=0\delta_c=0. A line states the event of cc when it asserts the recorded value of cc without negation, in a clause that names a subject of cc and a term of its relation. An ordered value must list its items in the recorded order, and a duration must be stated as an interval. With m=∑c∈Cqδcm=\sum_{c\in C_q}\delta_c matched criteria, precision P=m/LP=m/L and recall R=m/∣Cq∣R=m/|C_q| give

revid=2PRP+R=2mL+∣Cq∣,(9)r_{\mathrm{evid}}=\frac{2PR}{P+R}=\frac{2m}{L+|C_q|}, \tag*{(9)}

which is zero when no criterion is matched. The grounded score averages δcIoU⁡(Ik(c),ec⋆)\delta_c\operatorname{IoU}(I_{k(c)},e_c^\star) over CqC_q, where the IoU of two finite unions of intervals is the length of their intersection divided by the length of their union. In this score, ec⋆e_c^\star is widened by a factor ζ=1.4\zeta=1.4 about the center of each of its intervals and clipped to the video. A line that states a verified fact of the instance outside CqC_q is left out of LL, so a correct observation beyond the scored criteria costs no precision. When the criterion of qq declares alternative sets of supporting criteria, each set is scored as CqC_q, and the set with the highest revid+rgrdr_{\mathrm{evid}}+r_{\mathrm{grd}} is kept.

Novelty. The novelty reward credits the information that a proposal adds to its input, namely the intervals of its evidence lines, since the Questioner sees no timestamp of the events that a criterion rests on. It applies the grounded score of Eq. (3) to these lines,

rnov(q)=mean⁡c∈CqQδcIoU⁡(Ik(c),ec⋆),(10)r_{\mathrm{nov}}(q)=\operatorname{mean}_{c\in C_q^{Q}}\delta_c\operatorname{IoU}(I_{k(c)},e_c^\star), \tag*{(10)}

where CqQ⊆CqC_q^{Q}\subseteq C_q is formed from criterion cqc_q as for the Solver and leaves out every criterion whose interval is printed in cqc_q, the stem, or the options. Before scoring, a line whose every interval restates such a printed interval is dropped. A proposal with CqQ=∅C_q^{Q}=\varnothing receives rnov=0r_{\mathrm{nov}}=0, so copying a printed interval earns no credit.

Question Bank

Every measured canonical question enters the bank, so each instance contributes at least one stored question. Among the proposals that pass gate g(q)g(q) (§ 3.2), the bank preselects at most one per instance, favoring the task class that is rarest in the bank and, within it, the rarest task, and stores it once measured; at most 14 percent of a step’s instances contribute an interval question; proposals with g(q)=0g(q)=0 are neither answered nor stored. Each entry keeps the question, its verification context, the rule configuration and program graph of its instance, and the instance identifier. Replay reloads the rendered frames of the stored instance and answers them with the current policy. For every (family, task) pair and level, the bank keeps exponentially decayed pass-rate statistics, including counts of solved (p=1p=1), learnable (0<p<10<p<1), and unsolved (p=0p=0) questions, which the curriculum of § 3.3 and the rule-selection prompt read. The bank holds 640 questions shared across rounds; at capacity, eviction first removes questions of overrepresented task classes and families and then the oldest measurements, which keeps all task classes represented.

Group Relative Normalization and Policy Optimization

Policy parameters θ\theta are shared between Questioner πθQ\pi_{\theta}^{Q} and Solver πθS\pi_{\theta}^{S} and updated with Group Relative Policy Optimization (GRPO). The Solver forms groups GSG_S of M=8M=8 rollouts per question, and the Questioner forms groups GQG_Q of 4 proposals per instance. Both rewards subtract λdup=0.5\lambda_{\mathrm{dup}}=0.5 times the share of evidence lines that exactly repeat an earlier line; for the Questioner, this term lies outside the gate. A response is defective when it reaches the length cap, leaves its answer unclosed, loops, or, for the Solver, writes nothing before its answer. A defective proposal receives rQ=−1r^{\mathrm{Q}}=-1. A defective rollout receives 0.5 less than the lowest reward among the well-formed rollouts of its group, and its advantage is multiplied by its token count over their mean token count, clipped to [1,8][1,8], which restores the per-token weight that the sequence-mean loss takes from a long response. The advantage of each sample is its reward minus the group mean,

A^i=ri−1∣G∣∑j∈Grj(11)\hat{A}_i = r_i - \frac{1}{|G|}\sum_{j\in G} r_j \tag*{(11)}

without division by the group standard deviation, which keeps the scale of reward differences [25]. Groups whose rewards are all equal have zero advantage and are omitted from backpropagation. Both roles use the clipped surrogate objective with a Kullback–Leibler penalty βKL=10−3\beta_{\mathrm{KL}}=10^{-3} against the frozen reference policy πref\pi_{\mathrm{ref}}, the base model with adapters disabled. Training performs one combined Questioner–Solver update per step with AdamW at learning rate 5×10−55\times10^{-5}. The shared policy is held fixed throughout proposal sampling, Solver sampling, and reward evaluation, so each Questioner reward measures the current Solver without an intermediate parameter change. Each role’s advantages are centered within its own groups, and the optimizer receives the eligible groups of both roles.

Analysis Details

The analyses of § 4.4 use the recorded proposals, rollouts, rule decisions, and held-out evaluations of the 4B and 8B training runs.

Majority Voting and Interval Credit by Backbone

For every Solver group, majority voting takes the option chosen most often among the eight rollouts, and a tie leaves no majority label. Table 9 compares this label with the execution label. Every one of these groups is scored against a criterion that passed the recomputation and the static-question screen of § 3.1, and its ground-truth value equals the value recomputed on the sampled frames. Re-executing the programs of all instances reproduces the same traces, frame selections, and discarded criteria, so the execution labels are reproducible. The majority label is wrong for 56.8% and 48.2% of the groups at 4B and 8B and for 50.8% to 53.5% at each difficulty level, so it would mislabel about half of the training questions regardless of scale or video length. Wrong labels on which all eight rollouts agree are most frequent at 4B, where agreement filtering would keep a wrong label for 21.3% of the groups. The right half of the table covers all Solver rollouts. More than 90% of them receive some content-blind overlap. In 48.8% and 52.2% of these rollouts at 4B and 8B, the overlap comes only from lines whose statement does not match the criterion, so rgrdr_{\mathrm{grd}} gives them no interval credit. The grounded score keeps 36% to 38% of the content-blind credit, and the credit it keeps falls only on lines that state the correct event (Eq. (3)).

BackboneGroupsWrongOutvotedUnanimousTieWrong lineKept
4B3,70356.8223.1721.337.2448.7838.01
8B3,71748.2129.328.3410.3652.2136.44
Pooled7,42052.5126.2514.828.8050.5037.18

Table 9. Majority voting and interval credit. Left: Solver groups, with shares in % of groups whose majority label is wrong, whose majority label is wrong although at least one rollout chooses the correct option, whose eight rollouts agree on a wrong option, and whose vote ties. Right: Solver rollouts, with the share in % of rollouts credited by the content-blind overlap whose credit falls only on lines with a non-matching statement, and the share in % of the content-blind credit that rgrdr_{\mathrm{grd}} keeps.

Held-Out Instances

Each run builds its held-out set once from program seeds that no training round reaches. The 128 instances are balanced over families and levels at playback scales 1.0 and 2.0, and a candidate that fails the generation checks is replaced by another of the same family and level, so model answers never determine membership.

After every round, the policy answers the canonical question of each instance eight times. An answer counts as correct when it selects the ground-truth option. Evidence and grounded scores are revidr_{\mathrm{evid}} and rgrdr_{\mathrm{grd}} of Eq. (3). Table 10 shows that all three metrics exceed the base model after every round at both backbones.

BackboneMetricB12345
4BAccuracy22.927.932.732.433.231.1
4BEvidence24.340.442.141.743.747.0
4BGrounded3.17.68.97.110.010.8
8BAccuracy25.931.336.140.537.542.8
8BEvidence27.238.340.340.940.742.6
8BGrounded3.47.010.011.310.811.6

Table 10. Held-out instances. Accuracy, evidence score, and grounded score in % on the 128 held-out instances with eight answers each, for the base model (B) and after each of the five rounds; bold marks the best round.

Rule Decisions

Table 11 lists the 96 family decisions of the two runs. A decision keeps the rules either because the policy selects the current configuration or because its output fails a check of Appendix § 8.§ 5. Every alternative on the menus, 270 in total, compiles into usable instances in the runtime’s preview.

Backbone2345TotalSelectedFailed checkUsable alternatives
4B10127332124129 / 129
8B973524231141 / 141
Total191910856355270 / 270

Table 11. Rule decisions. Families whose rules change for each round, decisions that keep the rules by the policy’s selection or after a failed check, and menu alternatives with usable previews. Each backbone makes 12 decisions per round.

Controlled Comparisons

Ablation Variants

Table 12 defines the ablation variants of Table 3. Every variant starts from the same initialization and uses the same training budget, curriculum constants, and evaluation protocol as the full method, and it differs from the full method in exactly one component.

VariantChange from the full methodComponent tested
w/o novelty rewardRemove the novelty reward rnovr_{\mathrm{nov}} from rQr^{Q}Diversity of proposed questions
w/o learnability rewardRemove the learnability reward rlearnr_{\mathrm{learn}} from rQr^{Q}Targeting of questions at the Solver’s capability
w/o QuestionerTrain the Solver only on canonical questions, without Questioner proposalsSelf-proposed questions
w/o evidence scoreRemove the evidence score revidr_{\mathrm{evid}} from rSr^{S}Statement-level F1F_{1} of evidence lines
w/o grounded scoreRemove the grounded score rgrdr_{\mathrm{grd}} from rSr^{S}Interval credit on matched lines
Answer reward onlyKeep only the answer reward ransr_{\mathrm{ans}} in rSr^{S}Both evidence terms
w/o rule selectionKeep the initial rules in every round; the curriculum still reallocates instancesRule changes

Table 12. Ablation variants. Each variant changes one component of the full method.

Training Value of Evolved Environments

The comparison of Table 4 in § 4.4 fine-tunes the base Qwen3-VL-4B-Instruct checkpoint for one epoch on the questions stored in the bank at every round of one run, paired with the Solver responses recorded for them. The two runs are the ablation that keeps the initial rules (w/o rule selection) and the full method, whose rules evolve through rule selection; they use the same curriculum and budget and differ only in rule selection. The fine-tuned model does not select rules in this comparison, so differences between rows come from the data that rule selection produced.

Prompt Templates and Qualitative Rollout

The Questioner prompt (Listing 1) provides the video frames, the scene description and active rules, the askable criteria, one bank question of the same task, and the Solver’s pass rate per criterion; the listing shows its task statement and output format. The Solver prompt (Listing 2) specifies the format of evidence lines and answers. Both prompts remain fixed across all experiments; bracketed markers show where task specifications and environment inputs are inserted.

Listing 1 Questioner prompt (task statement and output format).

Write one multiple-choice question for one verified query below. Select a
query whose answer depends on when things happen: time-anchored observations,
their order, a duration, or the interval of an event.

[Rules on keeping the query, choosing admissible options, and the target
Solver success are inserted here.]

Before the proposal, find in the video the observations that determine the
selected query’s answer and write them as located evidence lines, with no tag
around them and no text before them: one line per observation. The proposal’s
grounding credit comes from these lines alone. Start each line with that
observation’s time span in this video’s seconds, read from the frame
timestamps, [[start,end]] or [[start,end],[start,end]], followed by one claim
stating the observation. A span copied from the query or the options earns no
credit. Then give the proposal between <answer> and </answer>, and write
nothing after </answer>.

[Scene and rules, verified queries with their distractor pools, current
feedback, and one prior example are inserted here.]

Return exactly:
[[START,END]] ONE LINE PER OBSERVATION THAT DETERMINES THE ANSWER
<answer>
criterion: QUERY_ID
question: QUESTION
options:
A. EXACT VERIFIED VALUE FROM THE SELECTED QUERY
B. DISTINCT DISTRACTOR FROM THAT QUERY
...
</answer>

Listing 2 Solver prompt (head and evidence-line rules).

Answer only the current question using the video.
Identify the observations needed to derive the answer: each relevant event,
or the visible states and operations being compared. Locate each observation
in the video before answering.
Each located line is checked on its own against the observations recorded
for this video: its claim must state one of them with the same object and
every identifying detail, and its interval must cover the time the video
shows it. A vague, merged or concluded claim matches none.
[Rules on naming subjects and choosing intervals are inserted here.]
Use as many evidence lines as the question needs. Each observation is
credited on one line; repeated copies of an observation and lines that state
no recorded observation lower the score. After the located lines, derive the
requested count, order, interval or state in plain lines without intervals,
then answer.
Start each line with its interval in this video’s seconds, read from the
timestamps shown with the frames: [[START,END]], or [[START,END],[START,END]]
for separate occurrences.
[The answer instruction, worked examples, the question, its options, and the
video are inserted here.]

Representative rollout example. Listing 3 shows a Solver response on a Billiards question. The question asks how the target ball’s quadrant changes between the start and the end of the video, with six options, where option F is a shift from the upper-left to the lower-left quadrant. The Solver cites two intervals corresponding to the initial and terminal observation frames, and its final line states the conclusion in the form the criterion is checked against.

Listing 3A Solver response on a Billiards question.
[[0.10, 0.60]] The pink ball is positioned in the upper-left quadrant at the start.
[[47.70, 48.00]] By the end, the pink ball is located in the lower-left quadrant, showing a movement from upper-left to lower-left.
<answer>F</answer>

Table 3 (PDF p. 26).

Limitations and Broader Impact

Limitations. Three constraints bound this study. First, the instruction-tuned backbones inherit visual and linguistic abilities from pretraining, and the executable environments shape only the self-play stage that follows. Second, the environments cover twelve hand-designed families of physical behavior with fixed task schemas and rule menus, and natural video has greater perceptual variability and commonsense breadth. Third, supervision relies on deterministic rendering and exact temporal coordinates, and the evidence terms credit only statements that match the verification criteria.

Broader impact. Tempo-Zero derives its training signal from executed programs, which reduces the need for scraped video and human temporal annotation. Because every training video is rendered from synthetic programs, self-play uses no private, copyrighted, or personal video data. As in other synthetic training methods, rule selection could be used to steer models toward narrow visual priors. Rule configurations are versioned, so the curriculum of every run can be inspected.

References

  1. [1]Shuai Bai, Yuxuan Cai, Ruizhe Chen, Keqin Chen, Xionghui Chen, Zesen Cheng, Lianghao Deng, Wei Ding, Chang Gao, Chunjang Ge, Wenbin Ge, Zhifang Guo, Qidong Huang, Jie Huang, Fei Huang, Binyuan Hui, Shutong Jiang, Zhaohai Li, Mingsheng Li, Mei Li, Kaixin Li, Zicheng Lin, Junyang Lin, Xuejing Liu, Jiawei Liu, Chenglong Liu, Yang Liu, Dayiheng Liu, Shixuan Liu, Dunjie Lu, Ruilin Luo, Chenxu Lv, Rui Men, Lingchen Meng, Xuancheng Ren, Xingzhang Ren, Sibo Song, Yuchong Sun, Jun Tang, Jianqian Wan, Peng Wang, Pengfei Wang, Qiu yue Wang, Yuxuan Wang, Tianbao Xie, Yiheng Xu, Haiyang Xu, Jin Xu, Zhibo Yang, Mingkun Yang, Jianxin Yang, An Yang, Bowen Yu, Fei Zhang, Hang Zhang, Xi Zhang, Bo Zheng, Humen Zhong, Jingren Zhou, Fan Zhou, Jing Zhou, Yuanzhi Zhu, and Ke Zhu. Qwen3-VL technical report. arXiv preprint arXiv:2511.21631, 2025. URL https://arxiv.org/abs/2511.21631.
  2. [2]Luke Bailey, Kaiyue Wen, Kefan Dong, Tatsunori Hashimoto, and Tengyu Ma. Scaling self-play with self-guidance. arXiv preprint arXiv:2604.20209, 2026. URL https://arxiv.org/abs/2604.20209.
  3. [3]Ellis Brown, Arjit Ray, Ranjay Krishna, Ross Girshick, Rob Fergus, and Saining Xie. SIMS-V: Simulated instruction-tuning for spatial video understanding. arXiv preprint arXiv:2511.04668, 2025. URL https://arxiv.org/abs/2511.04668.
  4. [4]Yukang Chen, Wei Huang, Baifeng Shi, Qinghao Hu, Hanrong Ye, Ligeng Zhu, Zhijian Liu, Pavlo Molchanov, Jan Kautz, Xiaojian Qi, Sifei Liu, Hongxu Yin, Yao Lu, and Song Han. Scaling RL to long videos. In Advances in Neural Information Processing Systems, 2025. URL https://arxiv.org/abs/2507.07966.
  5. [5]Zixiang Chen, Yihe Deng, Huizhuo Yuan, Kaixuan Ji, and Quanquan Gu. Self-play fine-tuning converts weak language models to strong language models. In Proceedings of the 41st International Conference on Machine Learning, 2024. URL https://arxiv.org/abs/2401.01335.
  6. [6]Kaituo Feng, Kaixiong Gong, Bohao Li, Zonghao Guo, Yibing Wang, Tianshuo Peng, Junfei Wu, Xiaoying Zhang, Benyou Wang, and Xiangyu Yue. Video-R1: Reinforcing video reasoning in MLLMs. In Advances in Neural Information Processing Systems, 2025. URL https://arxiv.org/abs/2503.21776.
  7. [7]Chaoyou Fu, Yuhan Dai, Yongdong Luo, Lei Li, Shuhuai Ren, Renrui Zhang, Zihan Wang, Chenyu Zhou, Yunhang Shen, Mengdan Zhang, Peixian Chen, Yanwei Li, Shaohui Lin, Sirui Zhao, Ke Li, Tong Xu, Xiawu Zheng, Enhong Chen, Caifeng Shan, Ran He, and Xing Sun. 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, pp. 24108–24118, 2025. URL https://openaccess.thecvf.com/content/CVPR2025/html/Fu_Video-MME_The_First-Ever_Comprehensive_Evaluation_Benchmark_of_Multi-modal_LLMs_in_CVPR_2025_paper.html.arxiv.org/abs/2405.21075
  8. [8]Jiyang Gao, Chen Sun, Zhenheng Yang, and Ram Nevatia. TALL: Temporal activity localization via language query. In Proceedings of the IEEE International Conference on Computer Vision, 2017. URL https://openaccess.thecvf.com/content_ICCV_2017/papers/Gao_TALL_Temporal_Activity_ICCV_2017_paper.pdf.arxiv.org/abs/1705.02101
  9. [10]Yicheng He, Chengsong Huang, Zongxia Li, Jiaxin Huang, and Yonghui Yang. VisPlay: Self-evolving vision-language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026. URL https://openaccess.thecvf.com/content/CVPR2026/papers/He_VisPlay_Self-Evolving_Vision-Language_Models_CVPR_2026_paper.pdf.arxiv.org/abs/2511.15661
  10. [11]Zefeng He, Xiaoye Qu, Yafu Li, Siyuan Huang, Daizong Liu, and Yu Cheng. VideoSSR: Video self-supervised reinforcement learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 26530–26540, 2026. URL https://arxiv.org/abs/2511.06281.
  11. [12]Kairui Hu, Penghao Wu, Fanyi Pu, Wang Xiao, Xiang Yue, Bo Li, Yuanhan Zhang, and Ziwei Liu. Video-MMMU: Evaluating knowledge acquisition from multidisciplinary professional videos. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 27798–27828. Association for Computational Linguistics, 2026. URL https://aclanthology.org/2026.acl-long.1281/.
  12. [13]Chengsong Huang, Wenhao Yu, Xiaoyang Wang, Hongming Zhang, Zongxia Li, Ruosen Li, Jiaxin Huang, Haitao Mi, and Dong Yu. R-Zero: Self-evolving reasoning LLM from zero data. In International Conference on Learning Representations, 2026. URL https://arxiv.org/abs/2508.05004.
  13. [14]De-An Huang, Shijia Liao, Subhashree Radhakrishnan, Hongxu Yin, Pavlo Molchanov, Zhiding Yu, and Jan Kautz. LITA: Language instructed temporal-localization assistant. In European Conference on Computer Vision, 2024. URL https://link.springer.com/chapter/10.1007/978-3-031-73039-9_12.arxiv.org/abs/2403.19046
  14. [15]Shiqi Huang, Ziyue Wang, Zhongrong Zuo, Han Qiu, Qi She, and Bihan Wen. EvoVid: Temporal-centric self-evolution for video large language models. arXiv preprint arXiv:2605.21931, 2026. URL https://arxiv.org/abs/2605.21931.
  15. [16]Alex Jacob, Andrej Jovanović, William F. Shen, Daniel Burkhardt, Meghdad Kurmanji, Nurbek Tastan, Lorenzo Sani, Niccolò Alberto Elia Venanzi, Jiayi Nie, Ambroise Odonnat, Zeyu Cao, Bill Marino, Xinchi Qiu, Rika Antonova, and Nicholas D. Lane. The Red Queen Gödel Machine: Co-evolving agents and their evaluators. arXiv preprint arXiv:2606.26294, 2026.
  16. [17]Minqi Jiang, Edward Grefenstette, and Tim Rocktäschel. Prioritized level replay. In Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 4940–4950. PMLR, 2021. URL http://proceedings.mlr.press/v139/jiang21b.html.arxiv.org/abs/2010.03934
  17. [18]Songtao Jiang, Sibo Song, Chenyi Zhou, Yuan Wang, Ruizhe Chen, Tongkun Guan, Ruilin Luo, Yan Zhang, Zhihang Tang, Yuchong Sun, Hang Zhang, Zhibo Yang, Shuai Bai, Junyang Lin, and Zuozhu Liu. Learning transferable temporal primitives for video reasoning via synthetic videos. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026. URL https://openaccess.thecvf.com/content/CVPR2026/html/Jiang_Learning_Transferable_Temporal_Primitives_for_Video_Reasoning_via_Synthetic_Videos_CVPR_2026_paper.html.
  18. [19]Ranjay Krishna, Kenji Hata, Frederic Ren, Li Fei-Fei, and Juan Carlos Niebles. Dense-captioning events in videos. In Proceedings of the IEEE International Conference on Computer Vision, pp. 706–715, 2017. URL https://openaccess.thecvf.com/content_iccv_2017/html/Krishna_Dense-Captioning_Events_in_ICCV_2017_paper.html.arxiv.org/abs/1705.00754
  19. [20]Dingming Li, Yingxiu Zhao, Xinrui Cheng, Khangheng Lin, Hongbo Peng, Hongxing Li, Zixuan Wang, Yuhong Dai, Haodong Li, Jia Wang, Yukang Shi, Liang Zhao, Jianjian Sun, Zheng Ge, Xiangyu Zhang, Weiming Lu, Jun Xiao, Yueting Zhuang, and Yongliang Shen. SpatialEvo: Self-evolving spatial intelligence via deterministic geometric environments. arXiv preprint arXiv:2604.14144, 2026. URL https://arxiv.org/abs/2604.14144.
  20. [21]Haodong Li, Tianfei Ren, Xiaoxiao Ma, Chunmei Qing, Zhen Fang, Sipeng He, Ziyu Guo, Haoyu Wu, Juanxi Tian, Yihang Zou, Ruichuan An, Dongzhi Jiang, Boxue Yang, Ji Xie, Xu Huang, Wenhao Yan, Jialv Zou, Zhengrong Yue, Yaxin Luo, Xiaotong Li, Yuzhu Wang, Junyan Ye, Jinjin Zhao, Zehui Chen, Lin Chen, Renye Yan, Feng Zhao, and Pheng-Ann Heng. VideoCoCo: Code-as-CoT for physically-consistent video generation via an agentic dual-engine system. arXiv preprint arXiv:2607.27380, 2026. URL https://arxiv.org/abs/2607.27380.
  21. [22]Bo Liu, Chuanyang Jin, Seungone Kim, Weizhe Yuan, Wenting Zhao, Ilia Kulikov, Xian Li, Sainbayar Sukhbaatar, Jack Lanchantin, and Jason Weston. SPICE: Self-play in corpus environments improves reasoning. arXiv preprint arXiv:2510.24684, 2025. URL https://arxiv.org/abs/2510.24684.
  22. [23]Bo Liu, Simon Yu, Yiding Jiang, Ao Qu, Andrew Zhao, Zichen Liu, Junsu Kim, Zijian Zhou, Seungone Kim, Tongzheng Ren, Mickel Liu, Hanfei Yu, Zhaorun Chen, Weiyan Shi, Paul Pu Liang, Luke Zettlemoyer, Yejin Choi, and Natasha Jacques. SPADE: Self-play in adaptive synthetic executable environments. arXiv preprint arXiv:2608.19197, 2026. URL https://arxiv.org/abs/2608.19197.
  23. [24]Wenqi Liu, Yunxiao Wang, Shijie Ma, Meng Liu, Qile Su, Tianke Zhang, Haonan Fan, Changyi Liu, Kaiyu Jiang, Jiankang Chen, Kaiyu Tang, Bin Wen, Fan Yang, Tingting Gao, Han Li, Yinwei Wei, and Xuemeng Song. VideoTemp-o3: Harmonizing temporal grounding and video understanding in agentic thinking-with-videos. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 78754–78776, 2026. URL https://proceedings.mlr.press/v306/liu26ej.html.
  24. [25]Zichen Liu, Changyu Chen, Wenjun Li, Penghui Qi, Tianyu Pang, Chao Du, Wee Sun Lee, and Min Lin. Understanding R1-Zero-like training: A critical perspective. In Conference on Language Modeling (COLM), 2025. URL https://openreview.net/forum?id=5PAF7PAY2Y.arxiv.org/abs/2503.20783
  25. [26]Jiahao Meng, Xiangtai Li, Haochen Wang, Yue Tan, Tao Zhang, Lingdong Kong, Yunhai Tong, Anran Wang, Zhiyang Teng, Yujing Wang, and Zhuochen Wang. Open-o3-Video: Grounded video reasoning with explicit spatio-temporal evidence. In Proceedings of the 43rd International Conference on Machine Learning, 2026. URL https://arxiv.org/abs/2510.20579.
  26. [27]Jack Parker-Holder, Mingi Jiang, Michael Dennis, Mikayel Samvelyan, Jakob Foerster, Edward Grefenstette, and Tim Rocktäschel. Evolving curricula with regret-based environment design. In Proceedings of the 39th International Conference on Machine Learning, volume 162 of Proceedings of Machine Learning Research, pp. 17473–17498. PMLR, 2022. URL https://proceedings.mlr.press/v162/parker-holder22a.html.
  27. [28]Tianyuan Qu, Longxiang Tang, Bohao Peng, Senqiao Yang, Bei Yu, and Jiaya Jia. Does your vision-language model get lost in the long video sampling dilemma? In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 20889–20899, 2025. URL https://openaccess.thecvf.com/content/ICCV2025/html/Qu_Does_Your_Vision-Language_Model_Get_Lost_in_the_Long_Video_ICCV_2025_paper.html.arxiv.org/abs/2503.12496
  28. [29]Hanoona Rasheed, Abdelrahman Shaker, Anqi Tang, Muhammad Maaz, Ming-Hsuan Yang, Salman Khan, and Fahad Shahbaz Khan. VideoMathQA: Benchmarking mathematical reasoning via multimodal understanding in video. In International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=VI4kGUfPio.arxiv.org/abs/2506.05349
  29. [30]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. DeepSeekMath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024. URL https://arxiv.org/abs/2402.03300.
  30. [31]David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of Go without human knowledge. Nature, 550(7676):354–359, 2017.DOI
  31. [32]Han Wang, Yi Yang, Jingyuan Hu, Minfeng Zhu, and Wei Chen. V-Zero: Self-improving multimodal reasoning with zero annotation. arXiv preprint arXiv:2601.10094, 2026. URL https://arxiv.org/abs/2601.10094.
  32. [33]Hanyang Wang, Yimo Cai, Weiliang Chen, Jiawei Chi, Haowen Sun, Qiyu Dai, Yi-Hsin Hung, Xingzhuo Guo, Jinshan Ren, Runmao Yao, Ziwei Liu, Mingsheng Long, Yueqi Duan, Jun Gao, Jiangran Lyu, Fangfu Liu, and Jialong Wu. Code as worlds: Agentic discovery of executable world representations for physical reasoning. arXiv preprint arXiv:2608.27549, 2026. URL https://arxiv.org/abs/2608.27549.
  33. [34]Qi Wang, Yanrui Yu, Ye Yuan, Rui Mao, and Tianfei Zhou. VideoRFT: Incentivizing video reasoning capability in MLLMs via reinforced fine-tuning. In Advances in Neural Information Processing Systems, 2025. URL https://arxiv.org/abs/2505.12434.
  34. [35]Qinsi Wang, Bo Liu, Tianyi Zhou, Jing Shi, Yueqian Lin, Yiran Chen, Hai Helen Li, Kun Wan, and Wentian Zhao. Vision-Zero: Scalable VLM self-evolution via multi-agent self-play. In International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=s00SNXREV6.
  35. [36]Wenyi Wang, Piotr Piękos, Li Nanbo, Firas Laakom, Yimeng Chen, Mateusz Ostaszewski, Mingchen Zhuge, and Jürgen Schmidhuber. Huxley-Gödel Machine: Human-level coding agent development by an approximation of the optimal self-improving machine. In International Conference on Learning Representations, 2026.arxiv.org/abs/2510.21614
  36. [37]Haoning Wu, Dongxu Li, Bei Chen, and Junnan Li. LongVideoBench: A benchmark for long-context interleaved video-language understanding. In Advances in Neural Information Processing Systems, volume 37, 2024. URL https://proceedings.neurips.cc/paper_files/paper/2024/hash/329ad516cf7a6306f98298e2c97755b-Abstract-Datasets_and_Benchmarks_Track.html.arxiv.org/abs/2407.15754
  37. [38]Junbin Xiao, Angela Yao, Yicong Li, and Tat-Seng Chua. Can I trust your answer? Visually grounded video question answering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024. URL https://arxiv.org/abs/2309.01327.
  38. [39]Kexin Yi, Chuang Gan, Yunzhu Li, Pushmeet Kohli, Jiajun Wu, Antonio Torralba, and Joshua B. Tenenbaum. CLEVRER: Collision events for video REpresentation and reasoning. In International Conference on Learning Representations, 2020. URL https://arxiv.org/abs/1910.01442.
  39. [40]Weizhe Yuan, Richard Yuanzhe Pang, Kyunghyun Cho, Xian Li, Sainbayar Sukhbaatar, Jing Xu, and Jason Weston. Self-rewarding language models. In Proceedings of the 41st International Conference on Machine Learning, 2024. URL https://arxiv.org/abs/2401.10020.
  40. [41]Jenny Zhang, Shengran Hu, Cong Lu, Robert Tjarko Lange, and Jeff Clune. Darwin Gödel Machine: Open-ended evolution of self-improving agents. In International Conference on Learning Representations, 2026.arxiv.org/abs/2505.22954
  41. [42]Ruixu Zhang, Deyi Ji, Lanyun Zhu, Xuanyi Liu, Yuxin Meng, Ruihang Chu, and Yujiu Yang. Video-Zero: Self-evolution video understanding. arXiv preprint arXiv:2605.14733, 2026. URL https://arxiv.org/abs/2605.14733.
  42. [43]Andrew Zhao, Yiran Wu, Yang Yue, Tong Wu, Quentin Xu, Yang Yue, Matthieu Lin, Shenzhi Wang, Qingyun Wu, Zilong Zheng, and Gao Huang. Absolute Zero: Reinforced self-play reasoning with zero data. In Advances in Neural Information Processing Systems, 2025. URL https://arxiv.org/abs/2505.03335.
  43. [44]Yilun Zhao, Haowei Zhang, Luojing Xie, Tongyan Hu, Guo Gan, Yitao Long, Zhiyuan Hu, Weiyuan Chen, Chuhan Li, Zhijian Xu, Chengywe Wang, Ziyao Shangguan, Zhenwen Liang, Yixin Liu, Chen Zhao, and Arman Cohan. MMVU: Measuring expert-level multi-discipline video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8475–8489, 2025. URL https://openaccess.thecvf.com/content/CVPR2025/papers/Zhao_MMVU_Measuring_Expert-Level_Multi-Discipline_Video_Understanding_CVPR_2025_paper.pdf.arxiv.org/abs/2501.12380
  44. [45]Junjie Zhou, Yan Shu, Bo Zhao, Boya Wu, Zhengyang Liang, Shitao Xiao, Minghao Qin, Xi Yang, Yongping Xiong, Bo Zhang, Tiejun Huang, and Zheng Liu. MLVU: Benchmarking multi-task long video understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 13691–13701, 2025. URL https://openaccess.thecvf.com/content/CVPR2025/html/Zhou_MLVU_Benchmarking_Multi-task_Long_Video_Understanding_CVPR_2025_paper.html.arxiv.org/abs/2406.04264
  45. [46]Yanyan Zou, Chao Chen, Tung Sum Thomas Kwok, Jiayu Yang, Yunyun Hou, Jingmin Zhu, Zehang Luo, Shengjie Li, Yinhong Liu, Yingjia Wan, Chengzu Li, Tao Yu, Zhijiang Guo, Jiachen Liu, Sirui Wang, and Nan Duan. Data-centric recursive improvement for foundation models: A survey. Preprints, 2026. doi: 10.20944/preprints202609.0154.v1. URL https://doi.org/10.20944/preprints202609.0154.v1.

Paper details

vlnc:W_ah7q5xmj
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

generative AI tools

View statement
Looking for related papers…
Contents