Memory Papers
Memory Architecture

EchoPath: Execution-Level Replayable Memory for GUI Agents

AuthorsYao Zhao, Aditya Shanmugham, Swastik Roy, Yanxun Xu

arXiv 20262026
arXivPDF

TL;DR

EchoPath uses image-based target reaiming inside execution-level memories to cut median token cost by over 90% on OSWorld-Verified tasks.

SharePost on XLinkedIn

Read our summary here, or open the publisher PDF on the next tab.

THE PROBLEM

Recurrent GUI tasks waste tokens and time in fresh observe plan ground act loops

GUI agents repeatedly run full observe plan ground act loops even for tasks they have already completed, such as updating records and processing forms. This leads to median first pass costs around 572k tokens and 4.5 minutes per OSWorld-Verified task, making enterprise-scale recurrent work inefficient.

In production environments, agents operating browsers, productivity suites, and desktop applications must respect cost, latency, auditability, privacy, and control. Without executable memory, each repeated GUI workflow becomes another expensive reasoning pass instead of a reusable, inspectable procedure.

HOW IT WORKS

EchoPath architecture for execution level replayable memory

EchoPath centers on ActionLens, the EchoPath Memory Repository, a Replay Module, Memory Consolidation, and the Image-based Target-Reaiming (IBTR) algorithm to convert validated GUI traces into callable episodes. Each memory stores task intent keys, application labels, state preconditions, action programs, visual evidence, flexible bindings, validation artifacts, and lifecycle state.

You can think of EchoPath like a hybrid of RAM and a versioned procedure library: first runs record detailed execution traces, then consolidation turns them into parameterized tools that can be replayed deterministically. Instead of brittle coordinate scripts, EchoPath treats coordinates as visual evidence and re-aims them against the current screen.

This design lets EchoPath bypass fresh per step planning and GUI grounding when a task recurs under compatible conditions, while bounded fallback and lifecycle governance keep replay safe, auditable, and controllable in ways a plain context window cannot.

DIAGRAM

EchoPath replay flow with GUI target reaiming and fallback

This diagram shows how EchoPath binds a selected memory to the current GUI state using IBTR, then either executes or falls back to agentic grounding or planning.

DIAGRAM

EchoPath two pass evaluation pipeline on OSWorld Verified

This diagram shows how EchoPath constructs memories in a first pass and reuses them in a second pass under resolution shifts on OSWorld-Verified tasks.

PROCESS

How EchoPath Handles a GUI operation task lifecycle

  1. 01

    Task Input

    EchoPath receives a GUI operation task τ with user instruction, desktop context, and artifact evaluator, then routes control through ActionLens.

  2. 02

    Retrieve and Gate

    EchoPath queries the EchoPath Memory Repository using task intent keys, application labels, state preconditions, validation evidence, and action schema compatibility.

  3. 03

    Plan or Replay

    EchoPath either invokes the Replay Module to instantiate the stored action program with IBTR and flexible bindings, or falls back to memory guided or ordinary agentic planning.

  4. 04

    Execute and Artifact Eval

    EchoPath executes bound actions through ActionLens, then uses artifact evaluation and Memory Consolidation to promote, branch, repair, or retire replayable memories.

KEY CONTRIBUTIONS

Key Contributions

  • 01

    Standardized callable GUI memory schema

    EchoPath defines replayable memories with task intent keys, state preconditions, action programs, visual evidence, flexible bindings, validation artifacts, and lifecycle state, enabling deterministic reuse across 159 active OSWorld episodes.

  • 02

    Image based target reaiming algorithm

    EchoPath introduces the IBTR algorithm that treats stored coordinates as visual evidence, achieving 95.0% accepted matches under random scaling with median 0 pixel deviation.

  • 03

    Model agnostic replay harness and lifecycle

    EchoPath provides a harness combining ActionLens, retrieval and gating, flexible input rebinding, replay time GUI reaiming, deterministic execution, and governed lifecycle operations like promotion, branching, repair, deprecation, and quarantine.

RESULTS

By the Numbers

Success Rate

91.2%

-0.6 percentage points vs Synapse (91.8%)

Execution Tokens Consumption

20,370 tokens

-566,016 tokens vs Synapse (586,386 tokens median)

Second-pass time (seconds)

127.5 seconds

-188.2 seconds vs Synapse (315.7 seconds median)

Target-Reaiming Accept Rate

95.0%

Random scale IBTR accepted 190 of 200 coordinate actions

On OSWorld-Verified tasks, EchoPath’s replay layer with codex-gpt-5.5-medium maintains 91.2% second-pass success while slashing median token cost from roughly 572k first-pass tokens to 20,370 and beating Synapse’s 586,386 median tokens. These results show that execution-level replayable memory can replace repeated observe plan ground act loops without sacrificing reliability.

BENCHMARK

By the Numbers

On OSWorld-Verified tasks, EchoPath’s replay layer with codex-gpt-5.5-medium maintains 91.2% second-pass success while slashing median token cost from roughly 572k first-pass tokens to 20,370 and beating Synapse’s 586,386 median tokens. These results show that execution-level replayable memory can replace repeated observe plan ground act loops without sacrificing reliability.

BENCHMARK

Second pass memory replay efficiency on OSWorld Verified

Execution Tokens Consumption for EchoPath and Synapse across models.

KEY INSIGHT

The Counterintuitive Finding

EchoPath’s codex-gpt-5.5-medium replay achieves 91.2% success, only 0.6 percentage points below Synapse’s 91.8%, while using 20,370 vs 586,386 median tokens. EchoPath also cuts median second pass time from Synapse’s 315.7 seconds to 127.5 seconds, despite bypassing fresh per step planning and grounding.

This is surprising because one might expect direct replay to be brittle and less reliable than planning enhanced baselines like Synapse. Instead, EchoPath’s governed replay with IBTR and state gating preserves reliability while massively reducing computation, challenging assumptions that more reasoning is always safer.

WHY IT MATTERS

What this unlocks for the field

EchoPath unlocks execution level GUI memory where validated trajectories become MCP style callable tools with visual reaiming, flexible inputs, and lifecycle governance. Builders can now treat recurrent GUI workflows as reusable digital assets, reducing token cost and latency for forms, reports, and configuration tasks while keeping replay auditable and controllable.

This makes it practical to deploy GUI agents on employee workstations with local execution records, minimal hardware, and reduced screen sharing to online models. EchoPath’s schema and IBTR layer also provide a foundation for richer semantic UI contracts and organizational scale memory libraries.

~12 min read← Back to papers

Related papers

Memory Architecture

A Control Architecture for Training-Free Memory Use

Yanzhen Lu, Muchen Jiang et al.

· 2026

TAG routes low-confidence steps to uncertainty-based routing, filters them with guarded acceptance with rollback, chooses between bank selection across rule and exemplar memory, and prunes via evidence-based retirement inside a unified control loop. On SVAMP and ASDiv, TAG reaches 81.0% and 85.2% accuracy, improving over the 74.0% and 77.5% no-memory baselines while a compute-matched Retry baseline stays flat.

arXiv:2604.18206Read explainer

Questions about this paper?

Paper: EchoPath: Execution-Level Replayable Memory for GUI Agents

Answers use this explainer on Memory Papers.

Checking…