One Step, Four Clocks: How GUI Agents Fall Out of Step

1 Introduction

Graphical user interface (GUI) agents operate websites, phones, and desktops through clicks, keystrokes, and gestures (deng2023mind2web; zhou2024webarena; zheng2024seeact; rawles2025androidworld; xie2024osworld; qin2025uitars). Deployed interfaces do not wait for them: a page finishes loading, a prompt disappears, a target moves, and an earlier input keeps changing the application while the agent is still deciding. A click can be right for the frame the agent saw and wrong for the state in which it lands.

The usual notation hides this. In $o_t\rightarrow a_t\rightarrow o_{t+1}$, $t$ indexes interaction steps rather than seconds: it says what follows what, not how long observing, deciding, and acting take. Ordinary evaluation follows the notation. Either the task-relevant state is held fixed while the agent computes, or the chosen action is scored without regard to when it reaches the interface.

Recent benchmarks let the screen change between actions or supply video evidence (chen2025guiworld; liu2026dynamicgui; yao2026livingscreen), and two score an action by when it arrives (li2026aoi; dong2026aapt). In an audit of eighteen benchmarks (Appendix Appendix F) we did not find one that records the observation, commitment, and receipt times of an action while holding the evidence fixed and varying only whether the correct response can expire during the decision.

We measure the consequence by running the same seeded task instances under three conditions. In Paused, the state that requires a response remains valid while the agent decides. In Replay, the agent receives the same sequence of observations as in a matched Live run, but the response remains valid until the agent acts. In Live, the target state and the response window advance in wall-clock time. On a notification that disappears after a fixed window, our primary agent, a 27B vision–language model, succeeds in 100/100 Paused and Replay trials at every tested window; in Live it succeeds in 0/100 trials at every tested window shorter than its own deliberation time and in 100/100 at every longer window (Section 6.2). Since Live and Replay received the same frames in the same order, the difference comes from the correct response expiring while computation and delivery continue.

A natural explanation is that the agent is too slow. Slowness is part of the explanation but not all of it: two responses to the same event can reach the interface at the same moment while one was committed from the observation available when deliberation began and the other incorporated a change that arrived before commitment; if the change alters the correct response, the two actions have the same latency and different outcomes. We reproduce this situation under controlled timing. On a target that drifts during deliberation, with decision start, commitment, and receipt matched, changing only the observation used at commitment raises success from 0/100 to 100/100, and the error of the unchanged action equals the distance the target traveled during deliberation (Section 6.3). Conversely, holding the decision fixed and varying only its delivery delay changes the outcome of otherwise identical orders (Section 6.7). Latency records when an action arrived; it does not record which state of the target the action was based on. Figure fig:hero shows one recorded episode.

\begin{figure}[t] \centering \includegraphics[width=0.52\textwidth]{figures/hero_two_rows.png} \caption{One recorded Live episode of the drifting balloon (16 px/s, seed 1043), 27B model. Top: the click proposed from that frame, scored at the delivered action's receipt time; the balloon is 84 px away. Bottom: the delivered action, the same decision with its coordinate filled from the newest frame just before $D$; it lands 4 px from the balloon.} \end{figure}

We record four boundary events for every episode. E is the time of a task-relevant change in the Environment. O is the time at which a timestamped Observation of that change becomes available to the controller. D is the time at which the Decision becomes irrevocable. A is the time at which the target application receives the Action. We call them clocks because each advances on its own schedule, not because any must be periodic. Each interval has its own failure: the evidence may not reach O before it stops mattering; the decision may commit on a state that was replaced before D; an action that was valid at D may be invalid or late by A. These failures can overlap, and they are distinct from semantic, grounding, and input-delivery errors. On our generated tasks the event trace assigns each Live failure that Paused and Replay do not show to one or more of these conditions, and in scripted tests each intervention fixes only the failure it targets (Section 4.3). We also record $B$, the start of the model call, as an auxiliary marker for the beginning of deliberation.

When a relevant change reaches the agent before commitment, two things are required: the response must reach A while it is still valid, and the decision at D must use the newest relevant observation. Neither is sufficient on its own. On a static target with a short window, only earlier arrival helps; when the correct action changes before D and the window is long, only the newer state helps. Chronotope is a controller for the second requirement. It separates deliberation from final binding: a provisional action can leave one argument, here a click coordinate or the value to type, unfinished, and an observation that arrives after deliberation has begun fills it immediately before D. We call this late binding. The mechanism itself is not new. Our contribution is the measurement that shows when it is needed and when it is not: it succeeds under continuous drift; a full re-decision also succeeds after a single change that then holds still; neither helps when the change occurs after D; and a stale coordinate can land on the wrong object even though the model chose the right one.

This paper makes three contributions. The Paused–Replay–Live protocol, with four recorded event times, separates failures caused by change during computation from other failures and distinguishes missed evidence, outdated commitment, and post-commit invalidation. Controlled-timing experiments show that, with commitment and receipt times fixed, the state used at commitment changes the outcome, and that, with the decision and the committed action fixed, the delivery delay changes it. A late-binding controller corrects one of these cases, and further experiments show where it applies, where re-decision suffices, and where a change after commitment would require earlier delivery or predicting the state the application will be in when the action arrives (receipt-state prediction).

2 Related Work

Most GUI-agent benchmarks evaluate observation–action steps over websites, phones, and desktops (deng2023mind2web; zhou2024webarena; zheng2024seeact; rawles2025androidworld; xie2024osworld; qin2025uitars). Recent ones give agents richer temporal evidence: GUI videos (chen2025guiworld), states that appear and disappear between actions (liu2026dynamicgui), screens that change without new input (yao2026livingscreen), dynamic browser tasks (li2026aoi), and responses whose usefulness depends on arrival time (dong2026aapt). None of them, as released, holds the goal, events, evidence, and scorer fixed while varying only whether the correct response can expire during a single decision. Timing-aware control has a longer history. Partially observable MDPs (POMDPs) (kaelbling1998planning) model uncertainty about the state; delayed reinforcement learning (liotet2022delayed) displaces observations or actions in time; real-time and asynchronous formulations (travnik2018reactive; ramstedt2019realtime), robot controllers acting on aging images (yuan2022asynchronous), and age-of-information analysis (li2026engagement; dong2018age) let the environment advance while the controller computes. We apply the last view to GUI control and add the equal-timing comparison.

Other work intervenes at different points on the path. AOI, an agent that monitors the screen between its actions (li2026aoi), and streaming vision–language models process video incrementally or decide when enough evidence has arrived (chen2024videollmonline; zhang2025flashvstream; xu2026streamingvlm; qian2025dispider; zhang2025avila); both make newer evidence available, and we ask whether such evidence can change a decision that is already underway. World models, anticipatory planners, speculative systems, and anticipatory action preparation (AAPT) prepare or reuse work ahead of the event (cao2026mobiledreamer; liang2026anticipatory; zhang2025ufo2; dong2026aapt). Preparation applies when one of a small set of complete actions can be constructed before the event; late binding applies when the content of the action, such as a coordinate, is available only after it. A scripted comparison confirms the division (Appendix Appendix D, Table Table 10): a prepared click succeeds at every window on a fixed-layout notification, where every deliberating controller fails below its deliberation time, and scores 0/100 once the event reveals the content.

3 Four Event Times

\begin{figure}[t] \centering \includegraphics[width=0.8\textwidth]{figures/four_clocks_timeline.png} \caption{The four event times of one decision, with the failure that each interval can produce and the intervention that addresses it. $\tau$ is the source time (rendering time) of the observation supporting the committed action; on a drifting target a frozen coordinate misses by the travel $v (t_A-\tau)$.} \end{figure}

3.1 Event Boundaries and Timing Measures

E is recorded when the target enters an evaluator-defined task-relevant state; O when a timestamped observation is published at a common controller boundary, the same for every method, so that model-specific perception lies inside O→D; D when the action becomes irrevocable and is published for delivery; and A when the application first receives the input.

For a target event e and its response d, the response latency R(d,e)=t_A(d)-t_E(e) decomposes into L_EO=t_O(e)-t_E(e), L_OD=t_D(d)-t_O(e), and L_DA=t_A(d)-t_D(d). Here t_O(e) is the first observation containing usable evidence of e; a short-lived event that disappears without producing one is recorded as missed. With t_close(e) the end of the response window, the slack S_A(d,e)=t_close(e)-t_A(d) is positive when the action arrived in time and measures lateness when negative. Every admitted observation also carries the source time τ of the target state it depicts, so the age of the evidence behind a decision is known at D and at A; age is not itself an error, since an old frame stays valid on a static screen.

3.2 Application-Time Outcomes and Failure Labels

Every episode is scored at receipt, never at commitment. Application-time success Y_g(d) judges the committed action against the target state immediately before receipt, s(t_A(d)^-), and a task-specific score, which we call the return G_g(d), is computed from the terminal trace, with the return defined for successful, failed, late, wait, and no-action traces; an action is scored against the state in which it arrives, so a click on a target that has already disappeared scores the same as no click.

The evaluator may assign more than one failure label. Missed evidence: no usable observation of the relevant event arrived before it ceased to matter. Outdated at commitment: the action fit the state used by the decision, but a newer relevant state was available before $D$ and required a different action. Invalidated after commitment: the action was valid at $D$ but not at $A$. Late: $A$ occurred after the window closed. An action wrong for the state that supported it is a semantic or grounding error; a mismatch between the action published at $D$ and the input received is an actuation error. Figure fig:classes (Appendix Appendix D) shows three recorded misses that differ only in these labels.

4 The Same Tasks Under Three Timing Conditions

4.1 Design and Scope

The task suite, released as the Chronotope Gym, tests whether competence measured while the response stays valid persists when the target and the window keep advancing. It has four generated task families, each reporting success at application receipt and a task-specific return: Task A (expiring response), a known response whose value decreases as the opportunity closes, with two environments that share the event structure but not the return: a desktop notification that disappears (return: click error) and a video player with a sponsor to skip (return: seconds of sponsor watched); Task B (synthetic trading), a signal that can appear, reverse, or expire before an order arrives; Task C (moving targets), with continuous drift (C1), a one-time jump (C2), a named target among crossing distractors (C3), and a Chromium-rendered page whose button a banner displaces; and Task D (changing code), a typed value that is replaced once while the agent deliberates. Appendix Appendix C gives the generators, returns, and scorer tests.

4.2 Paused, Replay, and Live Execution

All three conditions use the same instruction, seed, task events, action meanings, and evaluation rule; Replay and Live additionally present identical frames at identical controller times, and Paused presents only the triggering frame. Paused presents the response-triggering frame and keeps it valid until the action arrives. Replay presents the observations of the matched Live episode, the same frames at the same offsets from episode start, verified for every retained pair (Appendix Appendix C), and likewise keeps the response valid. Live releases the same observations on their original schedule while target state and window advance. Replay–Live is the primary contrast because it holds the observation stream fixed and changes only whether validity advances during deliberation. Replay controls for the agent's input, not for the controller: a controller that updates a field from later frames would be scored against the pinned state it correctly moved away from, so controller comparisons run in Live only, against the click the same model call would have produced from its first frame, scored at the same arrival time (the same-decision counterfactual, Section 6.3).

4.3 Which Failure Does Each Intervention Test?

Gates at the O, D, and A boundaries let the harness hold E→A fixed while changing the state used at commitment, redistribute a fixed delay among the intervals, or change only delivery. Task variants expose transient evidence before O, relevant change before D, a closing window, predictable change after D, and combinations, with static targets and irrelevant motion as negative controls; each is paired with the intervention designed for it (Appendix Appendix C, Table Table 6).

Because the conditions were constructed to match the interventions, the informative test is whether any intervention also corrects a neighboring condition. With a scripted controller whose only defect is the timing of its path, none does (Appendix Appendix C, Figure fig:o1-matrix); Section 6.4 repeats the test with the 27B model.

5 Late-Binding Controller

5.1 System and Control Operation

Chronotope is a reference controller for one of the suite's interventions: use the newest relevant state before commitment. We call the task suite and trace format the Chronotope Gym and this controller the reference late-binding controller; the physical Chronotope route of Appendix Appendix A is not evaluated. The controller receives timestamped observations at the $O$ boundary, runs the agent, and publishes a complete action at $D$; the application records $A$ in its input handler, and each rendered state carries an evaluator-only identifier and timestamp that is removed before the frame reaches the agent (Appendix Appendix A).

A provisional action stores its decision identifier, the action itself (click, type, or wait), the object or element the model intended to act on, any argument left unfinished (the click coordinate or the value to type), and the version of the control state it was proposed from; that version advances only when an action-relevant field changes (in C1, when the tracked target moves more than a threshold), so irrelevant animation leaves the proposal untouched. Immediately before $D$ a small component we call the binder reads the newest frame available to the controller, fills the unfinished argument, and checks the action: if the action and its target still apply, the complete action is committed under the same decision identifier; otherwise the proposal is discarded and a new decision starts. The implemented check covers the intended target and one open argument, the click coordinate or the typed value; the change of action of Section 6.6 is exposed in the trace but not corrected.

6 Experiments

6.1 Agents and Experimental Protocol

Within a comparison the checkpoint, prompt, observation resolution, action grammar, decoding settings, task instance, and event schedule are fixed; only the controller's use of newer observations, or a timing gate, varies, and a scripted controller with direct access to the task state (a scripted oracle) replaces the model where model error would obscure a timing intervention. Every model family first passes a Paused competence check on the rendering used, so that Live failures are not attributed to timing for an agent that cannot perform the task even when the interface waits (Appendix Appendix E). Proportions carry Wilson 95% intervals, so a 100/100 cell is $[0.96,1.00]$ and a 0/100 cell $[0.00,0.04]$; paired contrasts use exact McNemar tests on discordant pairs, with $p$-values in the appendix.

6.2 When the Interface Continues to Change

We first run the 27B Qwen model on the notification rendering of Task A, in which the valid response disappears after a configurable window. Deliberating 5.1–5.3 s in all 500 Live trials, it succeeds in 100/100 Paused and Replay trials at each of five windows (1, 2, 4, 8, and 16 s) and, in Live, in 0/100 at every window shorter than its deliberation and 100/100 at every longer one (Table Table 1). A finer sweep places the transition between 5.2 and 5.4 s, at the model's own median $E\!\rightarrow\!A$ of 5.36 s. The same weights served in NVFP4 deliberate 2.16 s and move the transition with them: 0/100 at 1 s, 4/100 at 2 s, 100/100 from 4 s (Table Table 1). Expressed as window over deliberation, both configurations fail below 1 and succeed above 1.1. Task C gives the same pattern at every speed, after the jump, and with distractors: Paused and Replay 100/100, Live 0/100, every failure outdated at commitment. Task B, an order on a chart signal that may reverse, fails only when the reversal precedes receipt: 0/100 (outdated at commitment) at 2.0 and 6.7 s after the signal, 100/100 at 10 s or with no reversal.

6.3 Late Binding on a Drifting Target

Can an observation that arrives during deliberation change the concrete action committed under the same decision identifier? In C1: Balloon Drift we hold the model call, decision identifier, observation stream, and the times $B$, $D$, and $A$ fixed; the only difference is which frame supplies the coordinate. A 24-pixel-wide red balloon moves horizontally across a $320\times240$ display while the 27B model returns click(x,y) or wait. A click succeeds only if it reaches the application within the response window and lands inside the balloon at $A$. Figure fig:hero shows one episode.

Four controllers start from the same model call (Table Table 9, Appendix Appendix D): the initial coordinate, which is the same decision's proposal scored at the same $A$ as the late-bound click (the same-decision counterfactual); a next-decision buffer, identical to it for the current action; restart-on-update, which adds replacement calls; and late binding, which replaces only $(x,y)$ from the newest pre-commit frame by template matching (Appendix Appendix C.8), with no access to the trajectory, hitbox, or generator state. The core comparison uses 100 disjoint trajectories at each of 0, 4, 8, and 16 px/s, and a boundary sweep adds 1 and 2 px/s (Figure fig:c1-results); a model call takes about 5.3 s and a binding about 63 ms. On the static and irrelevant-motion controls the binder returned zero translation in 100/100 and 99/100 trials (Appendix Appendix G), and an independently executed frozen controller agrees with the counterfactual scoring on 100/100 seeds at every speed.

The signed error of the initial coordinate equals $v\times5.3$ s to within about one pixel. The model had already chosen click on the correct target; only the coordinate was out of date. Updating the coordinate from the newest frame reduces the error to 2–4 pixels and raises success from 0/100 to 100/100 at 4, 8, and 16 px/s. On a second family, UI-TARS-1.5-7B, late binding raises success at 8 px/s from 0/100 to 69/100, against 70/100 on a static target; all 69 discordant pairs favor it (Appendix Appendix E).

\begin{figure}[t] \centering \includegraphics[width=0.42\textwidth]{figures/c1_error_law.png} \caption{The equal-timing comparison. Each pair of marks is one C1 decision (500 trials, 100 at each of 1–16 px/s). Horizontal axis: the balloon's travel between the frame the model used and the click's arrival, $v (t_A-\tau)$. Amber: distance from the initial coordinate to the balloon at $A$, on the identity line (median residual $+0.6$ px). Green: the same decision after late binding (median 2.2 px). Band: the 12-px half-width.} \end{figure}

Figure fig:pair shows the relation trial by trial. The initial-coordinate errors (amber) lie on the identity line: the miss equals the balloon's travel, so the model aimed correctly at the frame it was given, and the frame became stale. The late-bound clicks from the same decisions (green) all lie inside the balloon. The figure also shows where the update stops mattering: at 1 and 2 px/s the balloon moves 5–11 px in 5.3 s, less than its 12-px half-width, and the initial coordinate hits in 100/100 trials (Appendix Appendix D, Table Table 11); it fails from 4 px/s on.

6.4 Each Intervention Corrects a Different Failure

We repeat the scripted test of Section 4.3 with the 27B model on the balloon rendering, at the model's own timescale, with three conditions built to match three remedies: a 96-px jump 2 s after appearance with a 16-s window (change before $D$), a static target with a 6.5-s window (closing window), and drift at 16 px/s with a 16-s window (change that continues through $D\!\rightarrow\!A$). Table Table 2 gives the predicted pattern in all twelve cells: the newest state alone corrects the change before $D$ and nothing else, earlier receipt alone corrects only the closing window, and drift that continues through delivery under the slow route needs both.

6.5 When Does Late Binding Apply?

\subsubsection{A One-Time Jump: Late Binding or Re-decision}

C2: Balloon Jump changes the target once. The balloon moves by 96 px during deliberation and then stays still for the rest of a long window, so only the target state used to choose the coordinate changes. A control cell places the jump after receipt.

When the jump precedes $D$, the initial coordinate fails in 100/100 trials, each outdated at commitment; late binding succeeds in 100/100 with a 2-px error, having found the balloon 96 px away. When the jump follows $A$, the two controllers agree in every pair (Figure fig:c2-results, Appendix Appendix D).

Under the continuous drift of C1 restart produced no timely click in 100 trials, because the target moved during every replacement call; after a single jump it succeeds in 99/100, committing at 11.2 s instead of 5.1 s. Re-decision suffices when the changed state remains valid for another model call.

\subsubsection{Which Balloon, and Where It Is}

C3: Balloon Select adds two distractor balloons and names the target by color; the named balloon drifts at 8 px/s and one distractor crosses its path. The model selects the named balloon at $B$ in 100/100 trials under every controller; late binding reaches it in 99/100, the frozen counterfactual in 0/100, and 2 stale clicks land on a distractor that has crossed into the old position (Table Table 3): a stale location can look like a wrong identity.

\subsubsection{Updating a Typed Code, Not a Coordinate (Task D)}

Task D replaces the coordinate with a value: a panel shows a four-digit code from $E$, the action is type(value) into a field (16-s window), and the code is replaced once at 2 s (during deliberation), at 14 s (after receipt), or never; the binder decodes the code from the newest available frame just before $D$.

When the code changes before $D$ (Table Table 3), the initial value fails in every trial, 99 as outdated at commitment and one as a misread code that the decoder also corrects, and the same decisions with the value filled just before $D$ succeed in every trial; an independently executed frozen controller agrees with the counterfactual on 100/100 seeds. Restart-on-change also succeeds, 98/100, but commits at a median 9.3 s instead of 3.8 s (return $-9.1$ s); after $A$ and on a static code the controllers agree at 99–100/100. The update is therefore not limited to coordinates.

\subsubsection{A Chromium-Rendered Page}

A last moving-target variant renders a form page with Chromium ($640\times480$) and inserts a notice banner 2 s after the page appears, during deliberation, or 14 s after, pushing the Continue button down by 72–207 px (frames baked per seed). With 100 seeds per cell the pattern of C1 repeats (Table Table 3): when the banner arrives before $D$ the initial coordinate scores 0/100, every trial outdated at commitment, and its error equals the banner's displacement to within 3 px; the same decisions with the coordinate re-located just before $D$ score 100/100, and after $A$ the controllers agree (Figure fig:reflow, Appendix Appendix C).

6.6 An Animated Player Where the Required Action Changes

The video-player rendering of Task A (Figure fig:a1-player, Appendix Appendix D.1) has the notification's event structure, but the screen pans before the sponsor appears and the required action is a click on the sponsor's unlabeled skip button. With the same model, gate, windows, and 100 seeds, the Live transition occurs at the same window with the same labels (Table Table 1). At 8 and 16 s both score 100/100, but Live watches $-7.7$ s of sponsor against $-1.0$ s because the sponsor keeps playing during deliberation.

Second, at the 1-s window Replay also fails, 0/100 (Table Table 7), because the panning content starts a decision before the sponsor exists; that decision commits wait at 1.85 s (outdated at commitment), and the sponsor is gone before a click decision can start. The outdated action differs in kind, not in a field: a wait has no coordinate to update, so late binding cannot repair it, and only a controller that checks the action kind before $D$ and begins another decision could.

6.7 Delivery Delay Alone

The interval after $D$ can also decide the outcome on its own. A scripted oracle in Task B deliberates for a fixed 200 ms and commits the same valid order at the same $D$ in every trial; the signal reverses 20 ms after $D$, and only a seeded delivery delay, uniform on 0–40 ms, varies. Over 100 seeds (Appendix Appendix D, Figure fig:jitter), 44 orders arrive before the reversal and earn $+1$, 56 arrive after and earn $-1$, separated exactly at a 20-ms delay.

Under a jittered route no constant $A=D+c$ reproduces the outcomes, so $A$ is a required scoring boundary; whether the physical route makes it a practically independent clock remains to be measured.

7 Discussion and Limitations

\begin{figure}[htbp] \centering \includegraphics[width=0.68\textwidth]{figures/l1_collapse.png} \caption{Every Live trial on two trace-measured axes: (a) moving targets, success against the state change since the supporting frame normalized by the hit tolerance; (b) windowed tasks, success against the receipt slack. Dots are trials, markers are cells with Wilson intervals; both agents and both precisions sit on one step at $|\Delta|/r=1$ and $S_A=0$.} \end{figure}

What the four event times explain.

Pooled over every Live trial (Figure fig:l1), a logistic model on four trace features ($S_A$, the normalized state change since the supporting frame, whether the field was updated before $D$, and $D\!\rightarrow\!A$), fitted once on the 27B notification and C1 cells and applied without refitting to 3,296 held-out trials from the other tasks and agents, predicts success with accuracy 0.94 and log-loss 0.44, against 0.60 and 0.83 for a model on total response time alone; the rule “$S_A>0$ and $|\Delta|/r<1$” scores 0.97 (Appendix Appendix D). A stale coordinate and a stale wait receive the same label, but only the coordinate is a field the binder can update; a change of action kind must start another decision.

Which remedy, and when.

Late binding applies when the action kind and the intended target remain correct and one field can be updated from newer evidence, as in C1 and Task D. Re-decision suffices when the changed state remains valid for another model call, as after the jump in C2. Prediction addresses change after $D$ when the delivery delay is known (Figure fig:bindings).

Limitations.

The current evidence is limited in four ways. First, the Paused–Replay–Live rows come from one model family: the 27B model in two precisions passed the windowed-target check, and UI-TARS-1.5-7B reproduces only the balloon result (Section 6.3). Second, the experiments update one field per action, a click coordinate or a typed value, with rendering-specific binders; a change of action kind is diagnosed (Section 6.6) but not corrected. Third, prediction and delivery variation are simulated; the physical route's $D\!\rightarrow\!A$ distribution (Appendix Appendix A) is unmeasured. Fourth, the tasks are generated and largely one-response; the Chromium page is baked into frames, and no task tests long interactions in which earlier actions change later observations.

8 Conclusion

An agent that solves a task while the interface waits can fail it while the interface advances, and its response latency does not say why. Two clicks with the same start, commitment, and receipt times differ because one carries a 5-s-old coordinate, and its miss equals the target's travel in that time. Filling the field from the newest frame just before commitment succeeds; a full re-decision succeeds after a one-time jump but not under continuous drift; with the committed action fixed, a change after commitment is decided by the delivery delay. Choosing the right action is not enough; it must still be right when it arrives.

AI use statement

We used generative AI tools in this work, under the authors' direction, as follows. Claude (Anthropic), run as a coding agent, took part in research ideation and hypothesis refinement in discussion with the authors; proposed, designed, and gave feedback on experiments, including which studies would distinguish competing explanations; implemented the harness, study, analysis, and figure code; assisted in interpreting results and in the benchmark audit; and drafted and edited the manuscript text. Other commercial large language models produced written critiques of manuscript drafts, which informed revisions and additional experiments. Every reported result is recomputed deterministically from the immutable traces by author-reviewed analysis code; no reported number was produced, selected, or altered by a model outside that code. We reviewed all AI-assisted work. AI-generated code was reviewed by the authors and is covered by the scorer tests and regression tests of Appendix Appendix C; AI-proposed ideas, designs, and interpretations were checked by the authors against the recorded traces and the literature; every source in the benchmark audit was verified by the authors; and AI-assisted text and figures were reviewed and revised by the authors. We take responsibility for the final content of this work, including text, claims, and artifacts produced with the aid of generative AI.

Ethics statement

Chronotope studies software agents that can issue input to real applications. An outdated, late, or repeated action can cause unintended effects. The evaluation therefore uses controlled applications, evaluator-only instrumentation, and restricted target systems. The final release policy will document safeguards for any code capable of controlling external devices.

Reproducibility statement

We plan to release the task-suite API, versioned task generators, held-out seeds, Paused–Replay–Live scripts, timing gates, scorer tests, immutable trace schema, reference controllers, coordinate-calibration adapters, and analysis code. The release will include code that independently recomputes application-time success, task return, paired contrasts, and failure labels from raw events, together with regression tests for the timestamp and decision-join defects described in Appendix Appendix G. Every cell cited in this paper has a per-cell results file derived from the immutable traces by the analysis code. Every model cell in the main text has 100 held-out seeds; ten-seed pilots appear only in the appendix and are labeled as pilots wherever they appear.

References

The bibliography (iclr2027_conference.bib) is not part of this repository snapshot; citation keys are shown inline.

A Implementation Details

Added from measured results — inserted into paper.tex as a marked % ADDED block · new appendix section · LaTeX

B Qualitative Demonstrations

This appendix collects recorded episodes from the controlled suite. Every frame shown is a frame the controller actually received (content-addressed in the trace), every click marker is the committed action, and every timestamp is the recorded E, O, B, D, or A value; nothing is re-enacted. Two skins of the same episode structure are used: notification (a desktop on which a card with a button appears and counts down) for the static target, and balloon (a balloon that appears and may drift) for the moving target. The plain black-canvas skin used in the first measured runs is the control; results are never pooled across skins.

B.1 One Live episode, notification skin

B.2 The three Live failure classes

B.3 A real agent in Live: one invocation, too late (Qwen3.8-27B, notification skin)

B.4 A real agent in Live: wait, then click (seed 201, 8 s window)

B.5 Four bindings of the committed coordinate on a moving target

B.1 Physical Observation and Input Path

The intended physical boundary is the same as the software one: captured video of the target display enters the controller at $O$, committed actions leave it through a USB HID emulator, and the target application records $A$ in its input handler. No result in this paper comes from that route; its $E\!\rightarrow\!O$ and $D\!\rightarrow\!A$ distributions are deferred to a physical study.

B.2 Controller State and Commitment

Each C1 frame receives an observation version, and the trace records the frame used at binding. The action-relevant control-state version advances when tracked displacement crosses the movement threshold. The binder reads the newest available frame, avoiding sequential processing of older frames before commitment. Task D defines the typed value as its action-relevant field: its control-state version advances when the code decoded from the panel region changes, and the binder fills the value from the newest available frame by decoding the panel with the task's fixed glyph font. The completed results exercise these two binders, the C1 coordinate and the Task D value.

The C1 provisional action stores the decision identifier, action kind, selected target, proposed coordinate, binder, and control-state version. Initial coordinate publishes the proposed point unchanged. Next-decision buffering stores later frames without altering the current action. Restart-on-update discards the proposal and invokes the full model. Late binding applies normalized cross-correlation to a $25\times25$ patch around the proposed point, translates $(x,y)$ by the measured displacement, validates the target and action kind, and commits under the original decision identifier.

B.3 Source Time

Instrumented tasks associate each rendered state with an evaluator-only identifier and target-side timestamp. The identifier is recovered after capture, joined with the target log, and removed before the observation reaches the agent; the application records $A$ in its input handler. Software experiments inject observations at the common $O$ boundary, consume committed actions at $D$, and use one task clock for $E$, $O$, $D$, and simulated $A$, which enables exact replay and direct delay control. No claim in the paper depends on an unresolved cross-machine clock difference.

C Task Suite Reproducibility Details

C.1 Generator and Preservation Contract

Each generator emits an instruction, a seeded sequence of target states, rendered evidence, valid actions, and a response window. A Paused–Replay–Live triplet is accepted only when the instruction, event script, Replay/Live evidence, action semantics, and scorer match. Development and held-out seeds are disjoint. Generator versions fix event semantics, rendering, response windows, and scoring before held-out evaluation. A Replay trace records the hash of the Live trace it was built from; the pair validator compares the event trace and, observation by observation, the source event, source time, payload hash, and publication offset from episode origin. Over the 2,510 Replay–Live pairs behind Tables Table 1 and Table 7 and the static-player control, every pair validates with identical identities and a maximum offset difference of 0 ns; Replay therefore reproduces Live's publication cadence, not only its order.

Each immutable trace records the relevant environment events, admitted observations and source states, the supporting controller state when available, the complete action at D, the target state and response-window status at A, and the input received by the application. These records support both direct intervention and held-out repair of only the proposed failure point.

C.2 Task A: Expiring Response (Notification and Sponsor Player)

Task A uses an instrumented synthetic video player ($320\times240$) with a seeded sponsor interval. While the sponsor plays, the player shows a sponsor banner with a countdown and a plain, unlabeled skip button ($60\times24$ px, unique color); the notification rendering shows a card with a blue button instead. The action space is click(x,y) or wait in every study: a skip is a click received inside the button, and the scripted oracle clicks the same button. Sponsor onset defines $E$; the first published observation containing usable evidence defines $O$; commitment of the click defines $D$; and player receipt defines $A$. A later $E$ records the visible seek. The scorer reports timely success, sponsor time watched, repeated skips before the visible effect, and actions outside the valid interval.

C.3 Task B: Synthetic Live Trading

Task B streams a seeded synthetic price path into a chart and order panel. Each episode specifies an evaluator-defined response rule. The simulator supplies exact event times, market state, valid action, and action window, allowing a signal to appear briefly, reverse before commitment, or expire before receipt. The task evaluates timed rule following, not financial forecasting.

C.4 Task C: Synthetic Moving Targets

Task C logs exact target position at every update. C1 uses continuous horizontal drift. C2 moves the target once by 96 pixels and then holds it fixed; the jump time is a parameter, placed during deliberation (2 s) or after receipt (14 s) in the agent cells and swept across $B$, $D$, and $A$ in the oracle cells. C3 adds named targets and crossing distractors, logging target identity separately from committed coordinate and the object under the click at $A$. The binder may update only the coordinate associated with the model-selected target.

C.5 Task C on a Chromium-Rendered Page

The reflow variant is a form page with a heading, text, and a Continue button, rendered once per seed by headless Chromium into two frames, before and after a notice banner is inserted above the button, with the button geometry read from the DOM. The renderer shows the first frame until the banner time (2 s or 14 s after the page appears) and the second afterwards, so the manifest stays a pure function of task time; a live browser through the $O$ boundary is not used. The model sees the page at its native $640\times480$ (prompt 12); the binder is the C1 template matcher. Cells: banner at 2 s with frozen, late binding, and restart; banner at 14 s with frozen and late binding; seeds 1000–1099; Paused gate on the page without the banner.

\begin{figure}[h] \centering \includegraphics[width=0.9\textwidth]{figures/reflow_before_after.png} \caption{The Chromium-rendered page before (left) and after (right) the notice banner is inserted, seed 1000; the red box marks the Continue button, displaced by 192 px.} \end{figure}

C.6 Task D: Changing Code

Task D renders a code panel and a text field on the notification desktop ($320\times240$). The four-digit code is seeded, drawn with a fixed glyph font, shown from $E=0.5$ s, and replaced by a second seeded code at $E+2$ s, $E+14$ s, or never. The prompt asks the model to type the code currently shown; the schema admits type or wait with a value. Under late binding the value is left unresolved and filled just before $D$ by decoding the panel region of the newest available frame with the same font, evaluator-side and without the manifest; restart-on-change discards the proposal when the decoded value changes. Both binders are specific to their rendering: the C1 template matcher and the Task D glyph decoder. Success requires the typed value to equal the code shown at $A$; the return is minus the seconds from $E$ to the receipt of a correct value, with the window charged when none arrives. Cells: change at 2 s with frozen, late binding, and restart; change at 14 s and static with frozen and late binding; seeds 1000–1099; Paused gate on the static code.

C.7 Agent Interface and Shared Conditions

The unit of evaluation is an agent configuration: a checkpoint together with its observation policy, controller, serving arrangement, and delivery route; results are reported separately for each. The core adapter receives timestamped observations and publishes a complete action at $D$; the harness records application receipt at $A$. Instrumented adapters also expose the decision identifier, supporting observation identifiers, control-state version, and whether a relevant update was buffered, caused restart, or changed the current action. Direct comparisons fix the checkpoint, prompt, observation resolution, action grammar, decoding settings, task instance, and event schedule.

The standardized software track fixes the task generator, common $O$ boundary, timing gates, and receipt simulator; an end-to-end track can record a system's own capture, serving, controller, and input route. All completed results in this paper come from the software track. Every main comparison reports success rate and task-specific return; Live retention, failure composition, interval distributions, and task-specific diagnostics provide the explanation.

C.8 Agent and Serving Configuration

Table Table 5 lists the configuration shared by every model study. Prompts will be reproduced verbatim in the released code (prompt versions 4, 5, 8, 9, 10, and 11 for the notification, balloon, balloon-select, player, chart, and code-panel renderings; 7 for the UI-TARS native grammar); each states the task in two or three sentences, defines the coordinate convention, and asks for the JSON object only.

\begin{figure}[h] \centering \includegraphics[width=0.5\textwidth]{figures/o1_remedy_matrix.png} \caption{Interventions are selective. Rows are single interventions; columns are the failure conditions they were designed for; each cell counts successful clicks in 100 seeded Live episodes with a scripted controller whose only imperfection is the timing of its path. Each intervention repairs its own condition and none of the others; the combined condition needs both matching interventions. Static targets score 100/100 under every row (negative control, not shown).} \end{figure}

C.9 Metrics and Statistical Analysis

Every episode reports application-time success and task return. The video-player rendering of Task A uses $G_A=-T_{\mathrm{sponsor}}$; the notification rendering has no sponsor and, as a windowed-target task, reports the click-error return $G_C$ defined below, which is why Table Table 1 lists the two renderings in different units. Task B uses evaluator-defined utility $G_B=U_{\mathrm{order}}$. Task C uses $G_C=-e_{\mathrm{click}}$, the click's distance to the target at receipt, with the display diagonal charged when the target is absent at receipt or no click is received; it also reports coordinate translation, model calls, and response-window status at receipt. Timing reports include $E\!\rightarrow\!O$, $O\!\rightarrow\!D$, $D\!\rightarrow\!A$, total $E\!\rightarrow\!A$, receipt-time slack, and the source time of the observation supporting the committed action.

Binary proportions use Wilson 95% intervals, which remain informative at 0/$n$ and $n$/$n$ where the Wald interval collapses to zero width (brown2001interval). Paired binary outcomes use exact McNemar tests on the discordant pairs; continuous outcomes use paired intervals and permutation tests. Resampling operates on task instances or templates, not frames. Development runs are not pooled with held-out results.

C.10 Scorer Validation

Hand-authored traces with known outcomes test valid actions, invalid actions, wait, timeout, no received action, late receipt, missed evidence, outdated commitment, post-commit invalidation, semantic error, actuation error, duplicate action, and unresolved-action status. A second minimal scorer recomputes the principal success rates, returns, and paired contrasts from immutable events.

\FloatBarrier

D Additional Results

This appendix collects results that support the main text but are not needed to follow it.

D.1 Task A with the Model

\begin{figure}[h] \centering \includegraphics[width=0.92\textwidth]{figures/a1_player.png} \caption{Task A on the video player, 27B model, 100 seeds per cell. (a) One recorded Live episode at the 4-s window (seed 200). The frame at $B$ shows panning content and no sponsor; the first decision commits wait at 1.85 s ($D_1$), when the sponsor banner and its unlabeled skip button are already on screen; the second decision commits a click 5.2 s later, and at $A$ (7.22 s) the sponsor has been gone since 4.5 s. (b) Success at receipt versus response window, Wilson 95% intervals; dashed line, the median deliberation of the click decision. Paused and Replay coincide except at 1 s, where Replay also fails: the sponsor leaves before the first wait returns. (c) Mean return, seconds of sponsor watched: pinned, the seek delay only; Live, the wasted decision plus the deliberation; dotted, Live on the paired static player, 1.5 s better.} \end{figure}

The 27B model runs the sponsor task on a synthetic video player whose content pans before the sponsor starts, across the same windows as the notification rendering (Table Table 1; Paused gate 10/10; 100 held-out seeds per cell; 0 invalid trials). Median Live deliberation is 5.24 s, and the transition sits where the notification rendering places it, between the 4-s and 8-s windows; every Live failure at 2 and 4 s carries late and outdated at commitment (100/100 discordant Replay–Live pairs, exact $p=1.6\times10^{-30}$). At the 1-s window Replay also fails, 0/100, with the label outdated at commitment on a committed wait: the panning content triggers a decision before the sponsor appears, that decision commits wait at 1.85 s after the sponsor has appeared, and at 1 s the sponsor is gone before a click decision can begin (three wait decisions, no commit). At 2 s and more the click decision begins at 1.85 s and commits at 7.1 s, so first receipt is 6.7 s after onset against 5.2 s on the notification rendering. The paired static-player run (the player_static rendering: the same player with nothing moving before the sponsor; 100 seeds, the same seeds; Paused gate 10/10) has one decision per Live trial, beginning at 0.53 s, against two (three at 1 s) beginning at 0.05 s on the animated player. Success is identical in all 15 cells; the Live return is $-6.19$ and $-6.20$ s at 8 and 16 s against $-7.72$ s animated (paired $\Delta\bar G=+1.54$ and $+1.52$ s), and Replay at 1 s is 100/100 against 0/100 (100 discordant pairs, exact $p=1.6\times10^{-30}$). The cost of the wasted decision is therefore 1.5 s per trial, visible to the return and to Replay and invisible to the success rate.

\begin{figure}[h] \centering \includegraphics[width=0.32\textwidth]{figures/b1_jitter.png} \caption{A delivery-delay intervention (Section 6.7): Task B, scripted controller, 100 seeds. Every trial commits the same valid order at the same $D$; the signal reverses 20 ms later; only the delivery delay varies (uniform 0–40 ms). Orders received before the reversal earn $+1$ (green), after it $-1$ (red); every trial falls where its measured delay predicts.} \end{figure}

D.2 Reversal Position and Label

Task B's simulator can place a signal reversal anywhere on the timeline. Figure fig:b1-regimes and Table Table 8 keep the signal, the frames, the decision, and the committed order fixed and move only the reversal. If the world changes before the agent commits, and the agent had already seen the change, the label is outdated at commitment; if the world changes between commitment and arrival, the label is invalidated after commitment; if it changes after arrival, nothing is wrong. The same order earns $-1$, $-1$, and $+1$. Lateness is not involved in any of the three; the window is open throughout.

\begin{figure}[h] \centering \includegraphics[width=0.9\textwidth]{figures/b1_regimes.png} \caption{Task B reversal regimes on the four-event timeline (oracle controller, $D$ at 730 ms, $A$ at 790 ms). Three copies of the same trial differ only in when the signal reverses.} \end{figure}

D.3 Task A Return

An oracle sweep on the player (100 seeds per cell; compute time 0.5–5.2 s; seek delay 50 ms) validates the return definition $G_A=-T_{\mathrm{sponsor}}$: in Paused and Replay the return equals the seek delay whatever the compute time, because the sponsor waits; in Live every extra second of compute is a second more of sponsor watched, and once compute exceeds the sponsor length the skip never lands. The return therefore separates a late but valid skip from one that never arrives, which a success count cannot.

D.4 Which Remedy in Which Information Regime

D.5 Slow Targets and the Restart Threshold

\begin{figure}[h] \centering \includegraphics[width=\textwidth]{figures/c1_results_v1.png} \caption{C1 controller comparison. (a) Initial coordinate commits the point proposed at $O$; restart begins another model call after movement; late binding keeps the decision and updates only $(x,y)$ before $D$. (b) Hit rates over 100 trajectories per speed with 95% intervals; at each nonzero speed all 100 same-decision pairs favor late binding (exact McNemar, $p<10^{-29}$), and a 100/100 cell bounds the true rate only to $[0.96,1.00]$. (c) Under continuous drift, restart first commits after 17.6 seconds, compared with 5.1 seconds for late binding.} \end{figure}

Table Table 11 extends Figure fig:c1-results to 1 and 2 px/s. A target that moves less than its own half-width during deliberation is still hit by the first-frame coordinate, so late binding changes nothing there. Restart-on-update is a different story. At 2 px/s the movement detector fires, the controller discards a click that would have hit, calls the model again, and the target moves during every replacement call; 0/100 where doing nothing scores 100/100. A remedy triggered by motion can be worse than no remedy when the motion is harmless.

Raising restart's movement threshold moves this boundary and nothing else. With $\tau=12$ px the detector no longer fires at 2 px/s (travel $\approx$10 px), and restart then scores 100/100 there because it has become the same controller as the initial coordinate; at 4 px/s it fires under both thresholds and scores 0/100 under both, after 2.0 replacement calls and a first commit at 17.4 s. Over the six restart cells, restart succeeds exactly where the initial coordinate succeeds and fails exactly where its detector fires, because under continuous drift the target moves again during every replacement call. The threshold chooses where the failure begins; it cannot make re-decision outrun the target.

D.6 C3 Counts

Table Table 12 gives the C3 counts summarized in Section results:c3; Figure fig:c3-distractor shows one of the two trials in which the stale coordinate landed on a distractor.

\begin{figure}[h] \centering \includegraphics[width=0.5\textwidth]{figures/c3_distractor.png} \caption{C3 Balloon Select, seed 1010. Left: the frame at $B$; the model was told to click the yellow balloon and proposed a point on it. Right: the screen at $A$, 5.2 s later. The yellow balloon has drifted 41 px and the red distractor has crossed into its old position, so the initial coordinate lands on red and an outcome-only scorer would call it a wrong-object error. The late-bound click from the same decision hits yellow.} \end{figure}

D.7 Jump Position and Label

Figure fig:c2-results gives the agent counts behind Section results:restart-boundary. The oracle sweep of Figure fig:c2-oracle moves only the jump across $B$, $D$, and $A$ with a scripted clicker (500 ms of compute, 60 ms of delivery) whose four bindings share $B$, $D$, and $A$ exactly, 100 seeds per cell; every cell is 0/100 or 100/100.

\begin{figure}[h] \centering \includegraphics[width=0.72\textwidth]{figures/c2_oracle.png} \caption{Four bindings of the same committed click (shared $B$, $D$, $A$; scripted clicker; 100 seeds per cell) against the jump time; every cell is 0/100 or 100/100.} \end{figure}

\begin{figure}[h] \centering \includegraphics[width=0.42\textwidth]{figures/c2_bars.png} \caption{C2 Balloon Jump, 27B model, 100 seeds per cell, success at receipt with Wilson 95% intervals. A jump before $D$ defeats the initial coordinate but not the late-bound click of the same decision; restart-on-update also succeeds after a one-time jump but first commits at 11.2 s instead of 5.1 s. A jump after $A$ affects no controller.} \end{figure}

D.8 Receipt-State Prediction on a Drifting Target

The experiments with a real model update the coordinate from the newest pre-commit frame and do not predict where the target will be at $A$. An oracle sweep on the moving-target task characterizes that fourth intervention (Figure fig:bindings): a scripted clicker with 300 ms of compute and 100 ms of delivery commits the same decision under four bindings that share $B$, $D$, and $A$ exactly. Aiming at the state seen when deliberation began misses by the travel during the whole $B\!\rightarrow\!A$ interval; the newest state at $D$ removes the deliberation part but not the delivery part, which at 120 px/s is 12 px of horizontal travel, enough to miss a 6-px target; a velocity extrapolator that is told the true delivery delay lands within 1 px; the oracle lands exactly. The predictor's advantage is conditional on knowing the delay. When its delay estimate is wrong by $\Delta$, its error is $v |\Delta|$: at 120 px/s a 20-ms misestimate costs 2.4 px and still hits, a 40-ms misestimate costs 4.8 px and misses. Prediction therefore repairs post-commit change only to the extent that $D\!\rightarrow\!A$ is known, which is the operational reason Section 6.7 insists on measuring it.

\begin{figure}[h] \centering \includegraphics[width=\textwidth]{figures/balloon_bindings.png} \caption{Four bindings of the committed coordinate on a balloon drifting at 120 px/s (and 20 px/s upward) with $B$, $D$, $A$ matched (scripted clicker, 300 ms compute, 100 ms delivery). Left: the frame every binding saw at $B$. Then the screen at $A$ with each binding's click: the state at $B$ misses by 52 px, the newest state at $D$ by 17 px, the predicted state at $A$ by 1 px, the true state at $A$ by 0 px.} \end{figure}

D.9 Which Label a Closing Window Produces

\begin{figure}[h] \centering \includegraphics[width=\textwidth]{figures/oracle_failure_classes_notification.png}\par\vspace{4pt} \includegraphics[width=0.58\textwidth]{figures/wi001_label_phases.png} \caption{Top: the same closing, three labels. Each row is one Live cell of the scripted clicker with the window closing at 900 ms, shown as the frame at $B$, the newest frame at $D$, and the screen at $A$. Top: 355 ms of compute and 20 ms of delivery; the card is present at $D$ and gone at $A$ (invalidated after commitment). Middle: 400 ms of compute; the card was already gone at $D$, but no frame showing that had reached the controller (missed evidence). Bottom: 600 ms of compute; a frame showing the empty desktop was available before $D$ and the fixed-input decision committed regardless (outdated at commitment). For this controller the three classes are exhaustive and exclusive. Bottom: Which label a closing window produces. A scripted clicker on the windowed target (event at 500 ms, 400-ms window, 60-Hz frames, 30-ms publication delay), swept over compute and delivery. Green cells arrive in time. Along the diagonal boundary compute and delivery trade one for one; below it the failure is already decided at $D$, so delivery no longer matters.} \end{figure}

The three timing labels partition every oracle failure on the windowed-target task by where the closing falls relative to $O$, $D$, and $A$. Figure fig:classes (bottom) sweeps a scripted clicker's compute and delivery times against a 400-ms window. A decision that commits before the window closes but arrives after it is invalidated after commitment, and the boundary between that region and success is a diagonal because compute and delivery trade one for one; a decision that commits after the closing but before any frame depicting the closing could reach the controller is missed evidence; a decision that commits after such a frame has already been published is outdated at commitment. Late accompanies all three. The last two rows do not depend on delivery, because their failure is already decided at $D$. Every cell matches the closed-form prediction written independently of the harness.

\FloatBarrier

E Agent Qualification

Every agent configuration is admitted to a timing study only after clicking the target under Paused execution in at least 8 of 10 calibration seeds on the rendering used in that study. Table Table 13 lists every configuration tried. The 27B model passed on every rendering; the smaller general model answered wait on about half the frames that showed the target and was 13–25 px off when it clicked; the GUI-specialized model emits absolute pixels whatever the prompt asks (the mirror image of the Qwen family, which emits a 0–1000 grid whatever the prompt asks), so it was re-run in its own action grammar as the one declared alternative, and then passed on the balloon but read the synthetic desktop notification as a page still loading and waited. With a 64-token budget its native grammar was truncated before the action in every answer; the budget is therefore part of the controller specification. A timing comparison on an agent that cannot do the task while the world is paused would attribute its Live failures to time, which the protocol forbids; those configurations are reported here and used for no claim.

UI-TARS on the balloon.

UI-TARS-1.5-7B was the only second model family that passed a gate, in its native grammar on the balloon; it was run on the C1 subset at 100 held-out seeds (1000–1099) with the initial coordinate and with late binding at 0 and 8 px/s (median $B\!\rightarrow\!D$ 6.0 s). On the static target both controllers score 70/100 with identical clicks; the 30 misses are its own aiming error (median 4.5 px, 90th percentile 16 px, on a 12-px half-width), and the binder moved no static click (100/100 zero translation). At 8 px/s the initial coordinate scores 0/100 (69 outdated at commitment, 31 aiming errors) and late binding 69/100; all 69 discordant same-decision pairs favor late binding (exact McNemar $p=3.4\times10^{-21}$), and the frozen counterfactual agrees with an independent frozen run on every seed. Late binding therefore returns this agent to within one trial of its static-target accuracy; its ten-seed pilot (0/10 versus 6/10) is superseded, and its 9/10 gate result is a qualification check, not an estimate of that accuracy. It passes no windowed-target check, so it contributes no Paused–Replay–Live row.

\FloatBarrier

F Benchmark Audit

Table Table 14 summarizes an audit of eighteen GUI-agent benchmarks and one method, from their public harness code and papers as of 2026-08-22. Four questions were asked of each: does task-relevant state advance while the agent computes; can new observations arrive while a decision is in progress; is wall-clock decision time measured; and can the same action receive a different score solely because it arrives later. Most benchmarks either use static screenshots or run a live environment in a step-synchronous loop (capture, block on the model, execute, sleep), so the world effectively waits; three recent benchmarks let timed events run, and DynaCU-Bench and the AAPT testbed score when the action arrives. We did not find one that holds the evidence fixed while varying only whether validity advances during a decision, or one that records where between observation, commitment, and receipt the time went; that is the gap the Paused–Replay–Live protocol fills. Rows marked with a citation were audited from the released harness or evaluator code and the paper; DynamicGUIBench, AAPT, and OmniACT release no runner, so their rows rest on the paper and, for DynamicGUIBench, the task specifications. VideoGUI's evaluation code was not in its repository at the time of the audit. The audit file, with the consulted files, commit heads, and code excerpts for every row, will be included in the released artifact; the Online-Mind2Web and DynamicGUIBench rows were re-verified on 2026-08-24.

\FloatBarrier

G Protocol Corrections and Discarded Runs

Table Table 15 records every correction, exclusion, and post-run change that could affect a reported number. Two points bear on interpretation. Paused and Replay need not agree: Paused presents one frame while Replay presents the full ordered stream, so when wait is valid and the scene animates a deterministic agent can answer differently, which is why Replay–Live is the primary matched contrast. The binder used for the C1–C3 cells accepted the best normalized-cross-correlation match; a template with too little structure matches equally well in several places. The released binder also reports the second-best match outside the winner's footprint and leaves the binding unresolved, committing the proposal unchanged, when that match is within 0.05 of the best. Re-run on all 1,000 recorded C1–C3 bindings, the guard changes exactly one: the irrelevant-motion control click that moved 17 px, whose template re-occurred exactly at the new location. The reported cells stand as run.

Proposed additions to paper.tex

Every block marked “Added from measured results” above is listed here with its proposed location; the LaTeX that was inserted into paper.tex is behind each “LaTeX source” toggle. Nothing in the paper’s existing text has been altered on this page; collaborator margin notes (\TCWang) and source comments are omitted.

1. Measured Paused–Replay–Live result on the controlled one-response task (one agent, two skins)

Location: end of §“What Changes When the Target Does Not Wait?” · shown above

We report the first instances of the paired comparison on the controlled revealed target episode (target appears at 500 ms; 60 Hz frames; 30 ms observation publication delay; 20 ms declared delivery delay), in two skins of the same episode: plain (a 6 px square on a black canvas) and notification (a desktop on which a card with a blue button appears and counts down). The agent is Qwen3.8-27B (bf16, served locally by vLLM on one NVIDIA GB10), invoked once per frame change on one screenshot with a decoder-enforced JSON action on the model's native 0–1000 coordinate grid, temperature 0, thinking disabled. Under Paused it met the predeclared competence threshold on calibration seeds on both skins (10/10). On ten held-out seeds and windows of 1, 2, 4, 8, and 16 s: plain — Paused 10/10, Replay 10/10, Live 0/10 at 1–4 s and 10/10 at 8–16 s, median B→D 5.24 s; notification — Paused 8/10, Replay 8–10/10, Live 0/10 at 1–4 s and 10/10 at 8–16 s, median B→D 5.26 s. Live equals Paused exactly when the window exceeds the agent's measured path and every Live failure is labelled late and outdated at commitment. On the notification skin a Paused–Replay difference appears on two seeds: the model answers wait on the single triggering frame; under Paused no further frame arrives, whereas under Replay and Live the countdown animation triggers a second invocation that clicks at ≈7.8 s. All 320 trials were valid and all 100 Replay–Live pairs passed the evidence-identity validator. An earlier plain-skin run with a pixel-coordinate prompt (8/10 calibration, 5/10 evaluation, same Live transition) is superseded: several of its misses were exact in the 0–1000 normalized convention, so the coordinate space is now part of the agent's declared output grammar.

LaTeX source

We report the first instances of the paired comparison on the controlled \emph{revealed target} episode (target appears at 500\,ms; 60\,Hz frames; 30\,ms observation publication delay; 20\,ms declared delivery delay), in two skins of the same episode: \emph{plain} (a 6\,px square on a black canvas) and \emph{notification} (a desktop on which a card with a blue button appears and counts down). The agent is Qwen3.8-27B (bf16, served locally by vLLM on one NVIDIA GB10), invoked once per frame change on one screenshot with a decoder-enforced JSON action on the model's native 0--1000 coordinate grid, temperature 0, thinking disabled. Under Paused it met the predeclared competence threshold on calibration seeds on both skins (10/10). On ten held-out seeds and windows of 1, 2, 4, 8, and 16\,s: plain --- Paused 10/10, Replay 10/10, Live 0/10 at 1--4\,s and 10/10 at 8--16\,s, median $B\!\rightarrow\!D$ 5.24\,s; notification --- Paused 8/10, Replay 8--10/10, Live 0/10 at 1--4\,s and 10/10 at 8--16\,s, median $B\!\rightarrow\!D$ 5.26\,s. Live equals Paused exactly when the window exceeds the agent's measured path and every Live failure is labelled \emph{late} and \emph{outdated at commitment}. On the notification skin a Paused--Replay difference appears on two seeds: the model answers \texttt{wait} on the single triggering frame; under Paused no further frame arrives, whereas under Replay and Live the countdown animation triggers a second invocation that clicks at $\approx$7.8\,s. All 320 trials were valid and all 100 Replay--Live pairs passed the evidence-identity validator. An earlier plain-skin run with a pixel-coordinate prompt (8/10 calibration, 5/10 evaluation, same Live transition) is superseded: several of its misses were exact in the 0--1000 normalized convention, so the coordinate space is now part of the agent's declared output grammar.

2. Late binding with a real agent: a new observation changes the same unfinished decision before D (WI-004)

Location: end of §“Does Chronotope Implement Both?” (same-decision update paragraph) · shown above

Late binding with a real agent.

On the moving-balloon task (320×240 canvas, 24-px target, 16-s window so that lateness is not the failure under study), Qwen3.8-27B with thinking disabled (deliberation 5.2–5.3 s) was run under three at-commit policies sharing the same deliberative call: frozen commits the proposed click (state at B); restart if moved re-locates a pixel template cut at B in the newest frame at D and, if it moved by more than 6 px, discards the proposal and begins a new decision; late bind commits the re-located click under the same decision identifier. Because the late-bind trace records both clicks, the frozen outcome is also scored at the same A; it agreed with an independent frozen run on all 40 seeds. At v=4, 8, 16 px/s the frozen action was valid in 0/10 trials (mean error 22, 43, 84 px = v× 5.3 s) and the late-bound action in 10/10 (2.0, 2.5, 3.4 px); all ten paired seeds favour late binding at each velocity (exact McNemar p=0.002). At v=0 and under irrelevant motion the policies coincide on every seed. The binder took a median of 63 ms (maximum 72 ms; no failed matches in 50 bindings), which is how far D moves. Restart-after-update did not converge: the target had always moved by more than the threshold when a deliberation ended, so the controller restarted twice and committed only after the window closed (0/10 at every v>0, first-B-to-D≈18 s). With thinking enabled the same agent deliberated for 23–29 s in 24 of 40 trials and 34–97 s in the rest (32-s window): frozen 0/20, late-bound valid in every trial whose deliberation ended inside the window (12/12), every remaining failure late. The mechanism was admitted only after the calibration required by the implementation contract: on a static target the observations published during B→D cannot change the correct action, so there B is a profiling stamp; on a moving target the coordinate changes by v×5.3 s during deliberation and a fixed-input invocation cannot consume it.

LaTeX source

\paragraph{Late binding with a real agent.} On the moving-balloon task (320$\times$240 canvas, 24-px target, 16-s window so that lateness is not the failure under study), Qwen3.8-27B with thinking disabled (deliberation $5.2$--$5.3$\,s) was run under three at-commit policies sharing the same deliberative call: \emph{frozen} commits the proposed click (state at $B$); \emph{restart if moved} re-locates a pixel template cut at $B$ in the newest frame at $D$ and, if it moved by more than 6\,px, discards the proposal and begins a new decision; \emph{late bind} commits the re-located click under the same decision identifier. Because the late-bind trace records both clicks, the frozen outcome is also scored at the same $A$; it agreed with an independent frozen run on all 40 seeds. At $v=4$, $8$, $16$\,px/s the frozen action was valid in $0/10$ trials (mean error $22$, $43$, $84$\,px $= v\times 5.3$\,s) and the late-bound action in $10/10$ ($2.0$, $2.5$, $3.4$\,px); all ten paired seeds favour late binding at each velocity (exact McNemar $p=0.002$). At $v=0$ and under irrelevant motion the policies coincide on every seed. The binder took a median of $63$\,ms (maximum $72$\,ms; no failed matches in 50 bindings), which is how far $D$ moves. Restart-after-update did not converge: the target had always moved by more than the threshold when a deliberation ended, so the controller restarted twice and committed only after the window closed ($0/10$ at every $v>0$, first-$B$-to-$D\approx18$\,s). With thinking enabled the same agent deliberated for 23--29\,s in 24 of 40 trials and 34--97\,s in the rest (32-s window): frozen $0/20$, late-bound valid in every trial whose deliberation ended inside the window ($12/12$), every remaining failure \emph{late}. The mechanism was admitted only after the calibration required by the implementation contract: on a static target the observations published during $B\!\rightarrow\!D$ cannot change the correct action, so there $B$ is a profiling stamp; on a moving target the coordinate changes by $v\times5.3$\,s during deliberation and a fixed-input invocation cannot consume it.

3. Pre-commit change: when the target jumps before D, only the newer state at D helps (WI-009, oracle)

Location: end of §“Same-Decision Updating in Synthetic Moving Targets” (C2) · shown above

Pre-commit change under matched E, D, A.

On the jump-target task the target relocates by one full target width at a scripted time. With the deliberative interval, commitment time, and receipt time held identical across bindings (simulated clock, ten seeds per cell), a jump observed before D gives 0/10 valid receipts for the action bound to the state at B (every trial labelled outdated at commitment), 10/10 for the action bound to the newest state at D, and 0/10 for receipt-state prediction by velocity extrapolation, which treats the single displaced frame as motion and overshoots. A jump inside (D,A] gives 0/10 for every non-oracle binding (all labelled invalidated after commitment) and 10/10 for the oracle that knows the state at A; a jump after A gives 10/10 for every binding. The only non-oracle remedy for a discrete pre-commit change is therefore to read the newer state at commitment. With the real agent (balloon relocates by 96 px during the 5.3-s deliberation; ten seeds) the frozen action was valid in 0/10 trials, the late-bound action in 9/10, and restart-after-update in 10/10 with one restart per trial (first-B-to-D 11.6 s): a one-time change is where recomputation converges; with the jump after A all policies agree on every seed.

LaTeX source

\paragraph{Pre-commit change under matched $E$, $D$, $A$.} On the jump-target task the target relocates by one full target width at a scripted time. With the deliberative interval, commitment time, and receipt time held identical across bindings (simulated clock, ten seeds per cell), a jump observed before $D$ gives $0/10$ valid receipts for the action bound to the state at $B$ (every trial labelled \emph{outdated at commitment}), $10/10$ for the action bound to the newest state at $D$, and $0/10$ for receipt-state prediction by velocity extrapolation, which treats the single displaced frame as motion and overshoots. A jump inside $(D,A]$ gives $0/10$ for every non-oracle binding (all labelled \emph{invalidated after commitment}) and $10/10$ for the oracle that knows the state at $A$; a jump after $A$ gives $10/10$ for every binding. The only non-oracle remedy for a discrete pre-commit change is therefore to read the newer state at commitment. With the real agent (balloon relocates by 96\,px during the 5.3-s deliberation; ten seeds) the frozen action was valid in $0/10$ trials, the late-bound action in $9/10$, and restart-after-update in $10/10$ with one restart per trial (first-$B$-to-$D$ $11.6$\,s): a one-time change is where recomputation converges; with the jump after $A$ all policies agree on every seed.

4. C3 balloon select: the model chooses WHICH, the binder only keeps WHERE current (100 seeds)

Location: end of §“Same-Decision Updating in Synthetic Moving Targets” (C3) · shown above

Semantic choice vs. coordinate currency (C3).

Three balloons of different colours drift at similar speeds, one opposite, so trajectories cross; the instruction names one colour. The model chooses the balloon; the binder may only track the pixel patch around the model's own proposal (RGB template, ≈13 ms). Under Paused the model picked the named balloon on 100/100 calibration seeds. Live at 8 px/s (100 seeds per policy): the model again picked the named balloon in every trial; the frozen click was valid in 0/100 trials — and in 2 of them the aged coordinate landed on a crossing distractor that had drifted into the old position, converting a correct choice into a wrong-object click; the late-bound click was valid in 99/100 (the binder followed the chosen balloon through the crossings; the frozen counterfactual at the same A was 0/100); restart-after-update was valid in 0/100. No wrong pick occurred at n=100, so the requirement that a wrong choice must remain wrong after binding is enforced by contract tests with a scripted wrong-picker rather than exhibited by this model. Late binding returns the model to its own choice competence; it neither replaces nor repairs the choice.

LaTeX source

\paragraph{Semantic choice vs.\ coordinate currency (C3).} Three balloons of different colours drift at similar speeds, one opposite, so trajectories cross; the instruction names one colour. The model chooses the balloon; the binder may only track the pixel patch around the model's own proposal (RGB template, $\approx$13\,ms). Under Paused the model picked the named balloon on 100/100 calibration seeds. Live at 8\,px/s (100 seeds per policy): the model again picked the named balloon in every trial; the frozen click was valid in $0/100$ trials --- and in 2 of them the aged coordinate landed on a \emph{crossing distractor} that had drifted into the old position, converting a correct choice into a wrong-object click; the late-bound click was valid in $99/100$ (the binder followed the chosen balloon through the crossings; the frozen counterfactual at the same $A$ was $0/100$); restart-after-update was valid in $0/100$. No wrong pick occurred at $n=100$, so the requirement that a wrong choice must remain wrong after binding is enforced by contract tests with a scripted wrong-picker rather than exhibited by this model. Late binding returns the model to its own choice competence; it neither replaces nor repairs the choice.

5. Matched-state comparison with an oracle policy on a predictably moving target

Location: end of §“Why Is Total Response Latency Not Enough?” · shown above

With the oracle policy and B, D, and A matched exactly, we compared four bindings of the committed coordinate on a 6 px target moving at 120 px/s (oracle compute 100 ms, delivery 60 ms, five seeds): the state available when decision-making began (0/5 valid at A, mean error 22 px), the newest relevant state available at D (0/5, 12 px), the predicted state at A using a velocity estimate from admitted frames and declared delays (5/5, 1 px), and the true state at A as an oracle bound (5/5, 0 px). All four tie on a static target. The predictor's error grows by velocity × |estimate error| when its delivery-delay estimate is perturbed by ±20–60 ms. The trace records the second, third, and fourth bindings as separately identified coordinate corrections at commitment, not as same-decision updates.

LaTeX source

With the oracle policy and $B$, $D$, and $A$ matched exactly, we compared four bindings of the committed coordinate on a 6\,px target moving at 120\,px/s (oracle compute 100\,ms, delivery 60\,ms, five seeds): the state available when decision-making began (0/5 valid at $A$, mean error 22\,px), the newest relevant state available at $D$ (0/5, 12\,px), the predicted state at $A$ using a velocity estimate from admitted frames and declared delays (5/5, 1\,px), and the true state at $A$ as an oracle bound (5/5, 0\,px). All four tie on a static target. The predictor's error grows by velocity $\times$ $|$estimate error$|$ when its delivery-delay estimate is perturbed by $\pm$20--60\,ms. The trace records the second, third, and fourth bindings as separately identified coordinate corrections at commitment, not as same-decision updates.

6. Post-commit delay sweep with the oracle policy

Location: end of §“Four-Clock Interventions” (Results) · shown above

Holding E, O, and D fixed and adding delay only after D (0–200 ms), the oracle policy bound to the state available when decision-making began remained valid at A in every cell on a static target (0 px error), while on targets moving at 60 and 120 px/s it was invalid in every cell with spatial error at A growing linearly from 7 to 19 px and from 15 to 39 px respectively; Paused and Replay remained 5/5 throughout.

LaTeX source

Holding $E$, $O$, and $D$ fixed and adding delay only after $D$ (0--200\,ms), the oracle policy bound to the state available when decision-making began remained valid at $A$ in every cell on a static target (0\,px error), while on targets moving at 60 and 120\,px/s it was invalid in every cell with spatial error at $A$ growing linearly from 7 to 19\,px and from 15 to 39\,px respectively; Paused and Replay remained 5/5 throughout.

7. Agent configuration used in the first measured comparison

Location: end of §“Agents and Baselines” · shown above

The first measured comparison used one general-purpose vision–language agent, Qwen3.8-27B (bf16), served by vLLM on a single NVIDIA GB10 through a local OpenAI-compatible endpoint with structured output constrained to the action schema {click(x,y), wait} on the model's native 0–1000 coordinate grid; temperature 0, thinking disabled, one invocation per frame change. Measured B→D was ≈5.2 s (thinking off) and ≈23–25 s (thinking on, low effort).

LaTeX source

The first measured comparison used one general-purpose vision--language agent, Qwen3.8-27B (bf16), served by vLLM on a single NVIDIA GB10 through a local OpenAI-compatible endpoint with structured output constrained to the action schema $\{\texttt{click}(x,y), \texttt{wait}\}$ on the model's native 0--1000 coordinate grid; temperature 0, thinking disabled, one invocation per frame change. Measured $B\!\rightarrow\!D$ was $\approx$5.2\,s (thinking off) and $\approx$23--25\,s (thinking on, low effort).

8. Scorer and harness validation as performed

Location: end of §“Scorer Validation” (Appendix C) · shown above

The scorer was validated against a scripted oracle controller with declared compute and delivery delays, for which every Paused, Replay, and Live outcome and interval has a closed form written from the trial parameters alone (115 parameter combinations under a simulated clock; wall-clock cells match within 15 ms). For this controller the Live failure labels are exhaustive and mutually exclusive according to where the window close falls relative to its first published evidence, D, and A. Eighteen deliberately defective trials from the implementation contract are each rejected by the validator; the two residency defects are deferred to the CUDA-resident implementation.

LaTeX source

The scorer was validated against a scripted oracle controller with declared compute and delivery delays, for which every Paused, Replay, and Live outcome and interval has a closed form written from the trial parameters alone (115 parameter combinations under a simulated clock; wall-clock cells match within 15\,ms). For this controller the Live failure labels are exhaustive and mutually exclusive according to where the window close falls relative to its first published evidence, $D$, and $A$. Eighteen deliberately defective trials from the implementation contract are each rejected by the validator; the two residency defects are deferred to the CUDA-resident implementation.

9. Implemented and measured details (software-controlled realization only)

Location: end of §“Implementation Details” (Appendix A) · shown above

• Controller state: observation version vs. control-state version; commitment records both.
• Admission: every envelope recorded; newest pending retained; superseded frames coalesced at the next attention point.
• Commit: schema validation, version read/re-read, immutable record, D stamp, delivery; coordinate corrections at D are separate trace records.
• Timestamp sources: simulated discrete-event clock; monotonic wall clock with due-time stamping of lazily published frames.
• Serving: vLLM 0.27.1 on NVIDIA GB10, Qwen3.8-27B bf16, structured output via JSON schema; no remote API.

LaTeX source

\item Controller state: observation version vs.\ control-state version; commitment records both. \item Admission: every envelope recorded; newest pending retained; superseded frames coalesced at the next attention point. \item Commit: schema validation, version read/re-read, immutable record, $D$ stamp, delivery; coordinate corrections at $D$ are separate trace records. \item Timestamp sources: simulated discrete-event clock; monotonic wall clock with due-time stamping of lazily published frames. \item Serving: vLLM 0.27.1 on NVIDIA GB10, Qwen3.8-27B bf16, structured output via JSON schema; no remote API.

10. Observed failure cases in the measured comparisons

Location: end of §“Discussion and Limitations” · shown above

Three kinds of failure were observed: a coordinate-convention mismatch (answers on the model's native 0–1000 grid scored as misses under a pixel prompt; resolved by stating the grid in the prompt, raising plain-skin competence from 8/10 and 5/10 to 10/10 and 10/10); wait on the only frame (two notification-skin seeds: no action under Paused, a later click under Replay and Live once the countdown animation triggers a second invocation); and late commitments whose closing was observable before D but unusable by a fixed-input invocation.

LaTeX source

Three kinds of failure were observed: a coordinate-convention mismatch (answers on the model's native 0--1000 grid scored as misses under a pixel prompt; resolved by stating the grid in the prompt, raising plain-skin competence from 8/10 and 5/10 to 10/10 and 10/10); \texttt{wait} on the only frame (two notification-skin seeds: no action under Paused, a later click under Replay and Live once the countdown animation triggers a second invocation); and \emph{late} commitments whose closing was observable before $D$ but unusable by a fixed-input invocation.

11. What one Live episode looks like (notification skin, scripted clicker)

Location: end of §“Paused, Replay, and Live” · shown above

LaTeX source

\begin{figure}[t]\centering\includegraphics[width=\linewidth]{figures/notification_oracle_live_strip.png}\caption{Recorded frames from one Live episode in the notification skin (scripted clicker, 1.2\,s compute, 0.4\,s delivery, 1.5\,s window): the card's countdown drains, the card expires at 2{,}000\,ms, and the click committed at 1{,}730\,ms lands at 2{,}130\,ms on an empty desktop.}\label{fig:notification-live}\end{figure}

12. Screenshots: four ways to aim at a drifting balloon, matched B, D, A

Location: after the matched-state paragraph in §“Why Is Total Response Latency Not Enough?” · shown above

LaTeX source

\begin{figure}[t]\centering\includegraphics[width=\linewidth]{figures/balloon_bindings.png}\caption{Oracle policy on a drifting balloon (120\,px/s) with $B$, $D$, $A$ matched: the frame seen at $B$ and the screen at $A$ with the committed click of each binding.}\label{fig:bindings}\end{figure}

13. Screenshots: the three Live failure classes of the scripted clicker (notification skin)

Location: after the validation paragraph in §“Scorer Validation” (Appendix C) · shown above

LaTeX source

\begin{figure}[t]\centering\includegraphics[width=\linewidth]{figures/oracle_failure_classes_notification.png}\caption{Scripted clicker, three Live cells in the notification skin: frame at $B$, newest frame at $D$, screen at $A$, illustrating \emph{invalidated after commitment}, \emph{missed evidence}, and \emph{outdated at commitment}.}\label{fig:classes}\end{figure}

14. Qualitative Demonstrations

Location: new §“Qualitative Demonstrations” as Appendix B, immediately after Implementation Details (later appendices shift one letter) · shown above

Qualitative Demonstrations

This appendix collects recorded episodes from the controlled suite. Every frame shown is a frame the controller received, every click marker is the committed action, and every timestamp is the recorded E, O, B, D, or A value. Two skins of the same episode structure are used: notification (a desktop on which a card with a button appears and counts down) for the static target and balloon for the moving target; the plain black-canvas skin used in the first measured runs is the control, and results are never pooled across skins.

LaTeX source

\section{Qualitative Demonstrations}\label{appendix:demonstrations}
This appendix collects recorded episodes from the controlled suite. Every frame shown is a frame the controller received, every click marker is the committed action, and every timestamp is the recorded $E$, $O$, $B$, $D$, or $A$ value. Two skins of the same episode structure are used: \emph{notification} (a desktop on which a card with a button appears and counts down) for the static target and \emph{balloon} for the moving target; the plain black-canvas skin used in the first measured runs is the control, and results are never pooled across skins.
\begin{figure}[h]\centering\includegraphics[width=\linewidth]{figures/notification_oracle_live_strip.png}\caption{One Live episode (notification skin, scripted clicker: 1.2\,s compute, 0.4\,s delivery, 1.5\,s window). $B$ at 530\,ms; newest frame at $D$ (1{,}713\,ms); card gone at 2{,}113\,ms; click lands at $A=2{,}130$\,ms on an empty desktop (\emph{late}, \emph{invalidated after commitment}).}\end{figure}
\begin{figure}[h]\centering\includegraphics[width=\linewidth]{figures/oracle_failure_classes_notification.png}\caption{The three Live failure classes of the scripted clicker (window closes at 900\,ms): frame at $B$, newest frame at $D$, screen at $A$ for compute 355\,ms + delivery 20\,ms (\emph{invalidated after commitment}), 400\,ms (\emph{missed evidence} for the closing), and 600\,ms (\emph{outdated at commitment}).}\end{figure}
\begin{figure}[h]\centering\includegraphics[width=\linewidth]{figures/balloon_bindings.png}\caption{Four bindings of the committed coordinate on a balloon drifting at 120\,px/s with $B$, $D$, $A$ matched (scripted clicker, 300\,ms compute, 100\,ms delivery): errors at $A$ of 52, 17, 1, and 0\,px for the state at $B$, the newest state at $D$, the predicted state at $A$, and the true state at $A$.}\end{figure}

uv venv .venv && uv pip install --python .venv/bin/python pytest
.venv/bin/python -m pytest -q        # 183 tests
PYTHONPATH=src .venv/bin/python studies/c0_balloon_drift_oracle.py
PYTHONPATH=src .venv/bin/python studies/r1_revealed_target.py --model Qwen/Qwen3.8-27B --base-url http://127.0.0.1:8000/v1 --no-thinking --out runs/wi002_qwen38_nothink --max-calls 200