Skip to main content
Diagram of ECHOES system updating textual history state using CTA format, illustrating recursive text generation.

Editorial illustration for ECHOES Adopts CTA Format to Recursively Update Textual History State

ECHOES Agent Solves Memory Problem in GUI Automation

ECHOES Adopts CTA Format to Recursively Update Textual History State

• 4 min read

A GUI agent that has to click through forty screens to book a flight or fill out a form runs into a basic math problem: keep every screenshot and the token bill explodes, throw them away and replace them with text summaries and the agent starts forgetting what it already clicked. Researchers behind a new system called ECHOES are tackling that trade-off directly, framing it as a question of what long-horizon agents actually need to remember versus what they can afford to carry around.

The work, described in a paper on ECHOES and a companion benchmark called ECHOESBMK, targets a failure mode familiar to anyone who has watched an automated agent loop endlessly on a task it already completed, because its compressed memory dropped the detail that mattered. The authors built their benchmark from real GUI agent failure trajectories specifically to separate perception errors from memory errors, testing both at once.

Across four existing GUI benchmarks plus their own diagnostic set, the team reports gains in task completion and in what they call memory fidelity, without needing to store screenshots during deployment. That distinction, performance without the usual visual-history overhead, is the core claim the rest of the paper builds out in detail.

Specifically, ECHOES adopts a Compression-Think-Action (CTA) format to recursively update a textual history state and reason. The same model, given privileged multi-image inputs, serves as a teacher that provides dense token-level on-policy distillation on student-generated CTA rollouts.

Why this matters

The core bet here is that textual compression doesn't have to mean lossy compression, provided the model learns what to keep while it still has the pictures in front of it. That's the actual trick: using privileged multi-image access during training as a teacher signal, then stripping it away at inference so the deployed agent runs on cheap text state instead of a growing stack of screenshots. For anyone building long-horizon GUI agents, that's the bottleneck that's been forcing a trade-off between cost and reliability, and ECHOES is a concrete attempt to dodge it rather than just tolerate it.

The CTA format, Compress-Think-Action, is a clean enough idea that it's worth testing against your own agent's failure modes: does it lose track of state after ten steps, fifty, a hundred? We'd want to see this benchmarked on harder, longer tasks and against real production traces, not just curated eval sets, before treating token-level on-policy distillation as a settled recipe. Still, the framing, train with privileged vision, deploy on text, is a pattern worth watching beyond GUI agents specifically.

Common Questions Answered

What problem does ECHOES solve for GUI agents navigating multi-screen tasks?

ECHOES addresses the fundamental trade-off between storing all screenshots (which causes prohibitive token costs) and using text summaries (which causes agents to forget previous actions). By using recursive history compression with a Compression-Think-Action format, ECHOES enables long-horizon agents to maintain accurate memory of their actions while keeping computational costs manageable.

How does the Compression-Think-Action (CTA) format work in ECHOES?

The CTA format recursively updates a textual history state that the agent uses for reasoning and decision-making. Instead of accumulating screenshots, ECHOES compresses interaction history into text while maintaining the information needed for the agent to understand what it has already clicked and what actions remain.

What role do privileged multi-image inputs play in ECHOES training?

During training, ECHOES uses a teacher model that has access to multiple images to provide dense token-level on-policy distillation signals to the student model. This privileged access during training teaches the model what information to preserve in text compression, which can then be stripped away at inference time for cheaper deployment.

Why is textual compression in ECHOES not lossy despite being compressed?

ECHOES achieves lossless textual compression by having the model learn what to keep while it still has access to the original images during training. The model learns to preserve all critical information needed for task completion in compressed text form, rather than simply summarizing and losing details.

How does ECHOES reduce inference costs compared to storing full screenshot histories?

ECHOES deploys agents using only cheap text state representations instead of maintaining a growing stack of screenshots. By training the model to compress multi-image information into efficient text during the training phase, the deployed agent avoids the expensive token overhead of storing visual data while maintaining performance.

LIVE04:03NVIDIA CUDA Tile Primitives Accelerate Mamba-2 With Faster exp2 Operations