GUIFlow reuses yesterday's screen work. Track the cache when interfaces change

THE SIGNAL IN ONE SENTENCE

A computer-using agent can spend an impressive amount of silicon rediscovering that the toolbar is still where the toolbar was one second ago. GUIFlow, a new research system from a largely Tsinghua University team, tries to stop that repetition. The system treats a multi-step interface task as one evolving computation instead of a pile of unrelated screenshots. When the agent clicks a button, opens a menu or edits a field, much of the screen and interaction history remains stable. GUIFlow carries selected internal states forward, refreshes the regions that changed and verifies reused action fragments before letting them become the next command. The authors report up to 3.39 times less model computation on offline navigation benchmarks and up to 3.49 times less on closed-loop OSWorld tasks. Measured processing latency fell by factors of 1.94 to 2.55. That is a substantial result. It also comes with the oldest problem in caching: deciding when yesterday's answer is no longer today's answer. The basic opportunity is easy to see. A person filling out a form does not visually relearn the entire application after every keystroke. The sidebar, title bar, buttons and most fields usually remain unchanged. A vision-language agent, by contrast, may repeatedly encode the screenshot, rebuild the language model's context and generate a structurally similar action from scratch. GUIFlow looks for reusable work in all three places. First, it reuses historical key-value states from screenshots that remain in the agent's context. These internal states are position-aligned before being inserted into the new context because the same screenshot may have shifted as the interaction history grows. Second, it updates the current observation selectively. Pixel changes identify visual regions that need fresh processing. A mechanism the paper calls TokenLease compares current internal representations with the actual cached source and decides which deeper states can keep their lease and which must be recomputed. Third, it reuses the shape of previous action responses. If the agent recently produced a click command, an earlier click response can serve as a speculative draft. The target model checks the candidate tokens against the current context, accepts matching pieces and corrects the first mismatch. The old action proposes. The current model disposes. The system requires no extra training and no separate draft model. It also leaves the visible prompt and action interface unchanged. That makes the technique easier to imagine inside an existing agent stack. It does not make the technique invisible in production. The paper itself provides the right reason to keep a cache receipt. Across the evaluated tasks, more than 70 percent of screenshot pairs had no more than 5 percent pixel error even when the screenshots were four steps apart. Adjacent screens were even more similar. Most of the interface really was stable enough to invite reuse. But visual similarity is not semantic sameness. A tiny changed checkbox can authorize a large action. A one-line permission banner can alter what the agent is allowed to do. A dropdown may cover the same pixels while pointing at a different account. A notification can change the meaning of an unchanged submit button. The dangerous part of a screen is often small. GUIFlow includes several defenses against stale state. It caps repeated reuse of historical and current states. It triggers full recomputation when layouts are incompatible, changes are extensive or reuse limits expire. Its action drafts are verified by the target model rather than copied as final answers. Those are sensible engineering controls. Teams adopting this class of method should make them visible. For every agent step, a cache receipt should record the current screen fingerprint, the preceding screen, the changed regions, which visual tokens were recomputed, which deeper states were reused, how old those states were, whether an action draft was accepted and why a full refresh did or did not happen. The receipt should also record the result. The authors evaluated GUIFlow on AITW and Mind2Web for offline navigation, and on all 361 tasks in the OSWorld test split without Google Drive. Offline tests used Qwen3-VL 4B-Instruct and UI-TARS 1.5-7B. Online tests used Qwen3-VL 8B-Instruct and GUI-Owl 1.5-8B-Instruct. All experiments ran on NVIDIA GeForce RTX 4090 GPUs. On the offline benchmarks, GUIFlow reduced the reported model computation by 3.29 to 3.46 times across the four model and dataset combinations. Task scores stayed close to dense inference. On OSWorld, the Qwen model's mean score rose from 24.30 percent under dense inference to 27.90 percent with GUIFlow, while strict success rose from 23.55 to 26.87 percent. The GUI-Owl result moved the other way: mean score fell from 48.79 to 46.30 percent and strict success fell from 47.09 to 44.60 percent, while computation still dropped sharply. Aggregate similarity can hide application-level losses. In the GUI-Owl category table, the overall mean score was 2.49 percentage points below dense inference. Chrome was almost unchanged, and Impress improved. Writer fell by 8.70 points, VLC by 11.76, Calc by 6.38 and Thunderbird by 6.67. Those category numbers do not prove that caching caused every loss. Closed-loop agents can take different trajectories, and the paper notes that online efficiency records come from those different trajectories. They do show why one broad average should not approve a cache policy for every application. Compute speedup and wall-clock speedup also differ. GUIFlow cut reported floating-point operations by roughly threefold, while processing latency improved by roughly twofold. Memory access, cache management and input-output overhead still take time. Environment execution was excluded from the latency measurement, so the result does not say a full desktop task will always finish 2.55 times faster for an end user. The ablation is especially instructive. Historical key-value injection delivered the biggest initial reduction in model computation. Selective visual updates and TokenLease added further savings. Speculative decoding slightly increased total model operations in that configuration, but reduced cumulative server processing time from 27.51 to 17.85 seconds per task by replacing serial token generation with batched verification. That is a good reminder that efficiency is a system property. Fewer operations are useful. Fewer sequential waits may be more useful. Neither is the same as a correct click. Production teams should test cache invalidation the way database engineers test it: by trying to make stale state hurt. Move a button without changing its color. Replace the account behind an identical avatar. Open a modal over a familiar page. Change the selected tab. Insert a permission prompt. Let a field keep its shape while its unit changes. Refresh a list in place. Reorder two visually similar rows. Then ask whether the agent recomputed the right regions, rejected the stale draft and took the correct action. The acceptance test should include a full-refresh baseline. Run the same task with dense inference and with reuse enabled. Compare actions, task outcome, latency, computation, number of full recomputes and any human intervention. When the two paths diverge, preserve the screen sequence and state-age record. A mismatch is not merely a failed benchmark row. It is a cache-invalidation case the team can study. Authorization needs a separate line. GUIFlow accelerates inference. It does not decide whether an agent should be permitted to send an email, delete a file, approve a payment or change a system setting. A verified speculative token is verified against the model's current distribution, not against a person's intent or an organization's policy. The permission gate must sit outside the cache. High-impact actions should require current-state checks, explicit policy evaluation and human confirmation where appropriate, regardless of how confidently an internal state was reused. If the interface changes near a consequential control, a conservative system should prefer recomputation over thrift. GUIFlow is a new author-reported preprint. Its gains depend on the selected models, benchmarks, RTX 4090 hardware, task trajectories and fixed hyperparameters. The work shows that full-pipeline incremental inference can save real computation in a controlled evaluation. It does not establish a universal speedup or a safe deployment recipe for every website and desktop application. Still, the direction is practical. Computer-using agents do not need to forget the entire screen after every click. They do need to remember exactly what they reused. The cache can make the agent faster. The receipt is what lets a person decide whether faster was still right.