Source-linked AI summary
Echoverse: Deep, Evolving Environments for Training Computer-Use Agents at Scale
Yash Pandya, Sahil Gupta, Sarthak Harne, Archana Yadav, Kavyansh Chourasia, Hussein Mozannar, Vibhav Vineet, Sara Abdali, Corby Rosset, Yash Lara, Ahmed Awadallah, Ece Kamar, Akshay Nambi
TL;DR
Training computer-use agents requires environments where actions produce meaningful state changes, yet synthetic environments vary in behavioural depth and relevance to agents’ failures. Echoverse builds stateful applications and co-evolves them with model training; across tasks, deep, targeted and improving environments support stronger transfer, with reinforcement learning reaching 68.0% on held-out tasks.
Problem
Computer-use agents need running applications with consequential state changes, but a single deep application cannot supply the variability of interaction controls found on the live web.
Method
Echoverse compiles workflow specifications into stateful applications and uses each grounded rollout both to train the model and to improve the environment, tasks and verifiers.
Results
Across tasks, deep worlds transfer better than shallow ones, targeted controls transfer to held-out widgets and the open web, and reinforcement learning reaches 68.0% on held-out tasks.
Takeaways & Limitations
Effective synthetic-environment training depends more on finding and teaching missing capabilities than on maximizing the inventory of synthetic websites.
Takeaways & Limitations
Because the environment, corpus and verifier co-evolve, the reported gains cannot be cleanly attributed to the model alone or isolated through environment-only ablations.
Abstract
from arXiv · showhide
Computer-use agents learn from what their actions change, so training one needs applications it can act on, break and reset. The applications that matter most are login-gated and stateful, so synthetic environments stand in for them. Recent pipelines generate such environments in bulk, which moves the bottleneck from how many exist to what is inside each one. The returns, we find, come from three properties: how much behavioural depth an environment carries, whether it targets the interaction an agent actually fails, and whether it improves alongside the model. We present Echoverse, which compiles specifications into stateful applications whose tasks are graded against the application's own database, and a co-evolution loop that reads every graded rollout twice: as repairs to the environment, its tasks and its verifier, and as training signal for the model. Trained on twelve such environments, a 9B model improves from $36.5\%$ to $67.1\%$ across fourteen evaluation splits, within fourteen points of the much larger frontier model that taught it. We examine each property in turn. On the same domains, shallow environments push live-site accuracy below the base model ($80.0 \to 75.0$) while deep ones raise it ($80.0 \to 85.0$ and $48.0 \to 65.0$); drilling one interface control across many renderings transfers to held-out widget families and to the open web; and repairing a single environment lifts the model trained on it from $16.2\%$ to $38.5\%$. The same worlds serve as reinforcement-learning environments, where a reward combining the grounded verifier with a dense per-step judge raises held-out score from $58.8\%$ to $68.0\%$. We release four environments as a benchmark, with their applications, seed data and grounded graders. Code: https://aka.ms/echoverse
1 Introduction
Echoverse argues that effective computer-use training depends less on the number of synthetic worlds than on their behavioral depth, capability targeting, and continual co-evolution with the model. It builds resettable, database-grounded applications and uses every graded rollout both to train the model and to repair the world.
- Motivation: Computer-use agents need running, stateful applications because screenshots reveal appearance, while only actions with consequences reveal what the agent caused.Synthetic environments make these consequences safe to explore by owning the database and enabling resets.
- Problem: Once synthetic worlds are plentiful, the bottleneck is behavioral depth: coherent state, dependent workflows, recurring weak skills, and outcome-based verification.The paper defines worlds as applications, tasks, and verifiers bound together, shifting attention from count to what each world supports under real use.
- Approach: Echoverse uses three levers—depth, capability targeting, and co-evolution—to build worlds around executable workflows, recurring failures, and progressively sharper graded signals.Its thesis is to treat environment construction and model training as one repeated process rather than separate stages.
- Contributions: The paper contributes an operational depth definition, a two-phase factory, and a co-evolution loop that repairs worlds before trusting model failures without weakening task goals.Depth is completeness relative to target workflows, while tasks are proven solvable through the real interface and verified against live database state.
- Evidence and release: Echoverse supplies evidence that shallow worlds can underperform no training, added environments can continue helping, the same worlds support reinforcement learning, and four runnable worlds form a public benchmark.The benchmark includes seed databases, held-out evaluation tasks, and grounded verifiers, while withholding evaluation tasks from training.
2 Related work
Related work spans live-web benchmarks, resettable synthetic environments, database-grounded verification, and evolving task curricula. Echoverse studies the environments themselves, emphasizing task design, robust verifiers, and co-evolving software rather than only expanding task counts.
- Live-web benchmarks: Live-web benchmarks measure open-web competence but are limited to unauthenticated, logged-out interactions dominated by information finding.WebVoyager, Mind2Web, and Online-Mind2Web evaluate agents on real public websites, but cannot provide credentials or permit writes to strangers’ accounts.
- Synthetic environment suites: Synthetic suites provide hand-built, resettable applications with programmatic checks, while newer work automates their construction.WebArena, VisualWebArena, WorkArena, OSWorld, AndroidWorld, and BrowserGym established or consolidated these environments.
- What makes a training environment good: Prior requirements emphasize realism, explorability, data diversity and hydration, correct verifiers, and infrastructure stability, while Echoverse shares the conclusion that task design dominates task quantity.Environment diversity continues to help even as trajectory volume saturates.
- Verification: Database-grounded verification rejects answers that do not reproduce the application’s state, avoiding the blind spots of tolerant language-model judges during training.The paper extends database-state grading traditions such as τ-bench with a database round-trip as the verdict of record.
- Relation to our own prior work: This paper shifts attention from earlier mixed-pipeline computer-use agents to the environments themselves and their properties.Fara-7B and Fara-1.5 used data from pipelines combining live websites and synthetic environments, including an early version of these worlds.
3 Problem setting: environments, tasks and grounded grading
Echoverse models an environment as a stateful application whose database state enables exact resets and grounded rewards, while tasks specify database-derived references for read and write outcomes. Worlds combine environments, task corpora, and verifiers; their depth depends on whether target workflows are fully supported and leave precisely checkable state effects.
- Environment definition: An environment E = (S, A, T, O, D0) uses the application database as state, enabling grounded reward and exact reset.S is the database, T is the backend transition function, O is the observation mapping, and D0 is the seeded initial database.
- Task definition: A task τ = (g, r, κ) specifies a natural-language goal, task kind, and database-derived reference for READ, WRITE, or READ_WRITE outcomes.References are minted from D0 by executing SQL against the live database, making tasks true by construction.
- World definition: A world W = (E, T, V) is the trainable unit comprising an environment, task corpus, and verifier, all of which the co-evolution loop can repair.The environment is the application, whereas the world includes the tasks and grading mechanism.
- Grounded grading: WRITE passes only when the requested change appears in the sqldiff from pristine D0 to DT, preventing pre-existing state from satisfying the task.READ compares the response with a database-derived reference under semantic equivalence, while READ_WRITE scores the minimum of both checks.
- Grounded grading: Grading compares reported answers or state diffs with database-grounded references under fixed guidelines, making it harder to game and uniform across applications.The verifier targets narrow comparisons rather than judging long screenshot-only episodes, eliminating false positives from claimed success or public-web retrieval.
- Environment depth: A world is deep when its environment supports every target workflow end to end through the interface and leaves effects in state precise enough to check.Completeness is relative to the task corpus: unused product features are unnecessary, but missing a workflow-critical control makes the environment shallow.
4 Echoverse: the factory and the co-evolution loop … 4.3 Phase 2: growing the corpus
Echoverse is an agent-driven factory that compiles seeds into stateful, database-grounded applications and verified task corpora. Its two phases form a co-evolving loop in which failures repair the environment, tasks, and verifiers until the world and corpus meet verification standards.
- 4 Echoverse: the factory and the co-evolution loop: Echoverse produces full-domain worlds preserving realistic workflow depth and capability worlds isolating diagnosed interactions, with success grounded in application state.Both outputs rely on ownership of the underlying database rather than screenshot interpretation.
- 4.2 Phase 1: building the environment: Phase 1 expands hand-written seeds into specifications, verifiable claims, and complete applications spanning frontend, backend, and database.The generated world undergoes iterative verification and repair against its claims.
- 4.3 Phase 2: growing the corpus: Phase 2 regrounds seeds against live database state, generates tasks, evaluates quality and solvability, and re-scores repaired tasks against database-derived ground truth.Exported tasks carry the exact check used for grading.
- 4.1 An agent workforce: Every pipeline stage is assigned to agents that build artefacts, verify outputs, consolidate failures, and debug or roll back repairs.The workforce uses terminals, Playwright, and database tools exposed through the Model Context Protocol.
- 4.1 An agent workforce: Separating verification from construction and inserting triage between verification and repair lets one consolidated repair clear many tasks while preserving human oversight.Triagers plan fixes across shared causes rather than one task at a time.
- 4.2 Phase 1: building the environment: 95% of claims must pass before a world advances, after verifier agents exercise routes, state, and behavior against the running FastAPI, SQLite, and React application.Fixers repair the database, backend, or frontend until claims hold.
- 4.3 Phase 2: growing the corpus: 95% of the surviving corpus must pass verification, with failures tagged to database, backend, frontend, task text, or verifier and repaired through re-checking and rollback.Feasibility is white-box: agents drive the interface while reading source and querying the database directly.
- 4 Echoverse: the factory and the co-evolution loop: The phases are one co-evolution loop: environment defects are commonly re-versioned, harder tasks expose environmental gaps, and stronger environments support harder tasks.The loop does not stop when a world ships; model failures provide evidence about the world.
4.4 Seeding … 4.8 From tasks to trajectories
Echoverse combines grounded seeding, reproducible task isolation, rollout-level failure attribution, and environment repair before converting verified trajectories into training data. This pipeline prevents broken worlds from becoming supervision while allowing shared defects to be fixed across many tasks.
- 4.4 Seeding: ECHOSTAY uses InsideAirbnb listings, while ECHOFORUM uses a public corpus containing 2.55 million comments.These public datasets provide real listings, hosts, reviews, amenities, and forum comments rather than invented records.
- 4.5 Determinism, isolation and reset: Each rollout runs against an isolated per-task database copy, enabling exact reproduction without cross-task contamination.When seed data changes, the grounding database is regenerated, re-validated, and re-published; this reset primitive is reused for reinforcement learning.
- 4.6 One rollout, two signals: A failed score can reflect the agent, environment, task, or verifier, so failures are not automatically treated as capability gaps.The score measures a coupled stack rather than the model alone.
- 4.6 One rollout, two signals: Triage rechecks reachability, state existence, and grading correctness, then distinguishes world failures from model failures and repairs ambiguous cases.The same verifier and triage agents used by the factory perform this attribution.
- 4.7 Repair before training, and why one fix clears many tasks: Environment defects are repaired before failures become supervision, and goals are never weakened merely to raise pass rates.Broken-environment failures are treated as noise rather than useful learning targets.
- 4.7 Repair before training, and why one fix clears many tasks: Triage prioritizes shared causes because one broken control or interaction can block many tasks and a single repair can restore them simultaneously.Agent-driven execution also reveals interaction-specific defects that ordinary human QA may miss, such as guest-count controls silently retaining defaults.
- 4.8 From tasks to trajectories: After repair, GPT-5.4 solves tasks in the live environment, and only trajectories passing the grounded verifier enter the supervised fine-tuning corpus.Training-data selection is over trajectories rather than tasks; task existence was settled earlier by feasibility checks.
5 The environment suite
The environment suite targets behaviorally faithful, stateful workflows whose tasks are graded by the database state they leave behind. It combines ten full-domain worlds with capability worlds that mass-produce difficult controls across varied renderings and contexts.
- Full-domain worlds: The suite focuses on closed, proprietary workflows where permissions, shared state and history carry consequences across screens and users.Tasks execute real workflows and are graded on the resulting application state rather than pixels alone.
- Full-domain worlds: Five-to-thirty-action tasks in ECHOSTAY, ECHOMAIL and ECHOCARE finish only when booking, message or audit-trail state changes.ECHOSTAY spans roughly 87 routes and 23 tables without a confirmation shortcut.
- Capability worlds: Capability worlds isolate controls such as date pickers and nested filter-and-search interfaces, rendering them across layouts, states and constraints.The datepicker world uses six core widgets across ten contexts and 100 frontends in six visual styles, with held-out widgets across further scenarios and styles.
- Evaluation setup: Training covers twelve worlds, while evaluation uses fourteen splits: ten domain splits plus in-distribution and held-out splits for each capability world.Reported averages are unweighted means over the fourteen splits.
6 Supervised experiments
Supervised experiments show that deep, targeted, diverse environments improve computer-use agents more reliably than shallow or merely larger datasets. A co-evolution loop further improves performance by repairing environment failures alongside the model, while transfer to the live web remains limited by coverage.
- Main supervised result: 67.1%: πSFT improves the 9B model from 36.5% across fourteen evaluation splits, approaching GPT-5.4 within fourteen points.πSFT is trained on 21,009 verified trajectories from twelve worlds and evaluated with database-grounded verifiers.
- Targeted capabilities: 57.3 and 84.8: targeted training improves held-out date pickers from 34.0 and held-out filter panels from 62.8, while either skill also lifts the other.The results indicate rule-level transfer beyond layouts, including cross-skill transfer between datepicker and filter controls.
- Live-web transfer: 63.4: adding ECHOFORGE to an earlier training mix raises live GitHub performance from 58.5, with WebVoyager increasing from 50.9 to 52.9.πSFT is evaluated unchanged on WebVoyager and Online-Mind2Web, which it never trained on; the benchmarks differ substantially from the login-gated, write-heavy training worlds.
- Scaling data and environments: 54.8 →55.6 and 40.1 →37.2: increasing trajectories from 6,400 to 20,000 leaves WebVoyager nearly flat and reduces Online-Mind2Web performance.By contrast, expanding the number of environments keeps raising the in-domain average and gives WebVoyager its best result with the full set.
7 Reinforcement learning on the worlds
Echoverse enables reinforcement learning by providing resettable, scalable worlds with trusted database-grounded rewards, supplemented by dense per-step judging. On five worlds, reinforcement learning raises held-out judged score from 58.8% to 68.0%.
- Motivation: Imitation leaves agents without training examples for detecting and recovering from their own mistakes or judging when they are finished.Filtered successful trajectories contain no wrong turns being noticed and undone, while teacher failures do not match the failures of a 9B policy.
- Environment requirements: Echoverse supplies exact reset, parallel sampling, and trusted rewards through per-task database isolation and an existing grounded verifier.The same worlds can benchmark agents and train them, without new environment machinery.
- Reward design: Each rollout combines a database-grounded trajectory reward with a binary dense per-step reward from a multimodal judge, using Rrow = Rtraj + λ Rstep, λ = 1.The terminal verifier determines episode success, while the per-step term supplies shaping for intermediate actions whose states are usually neither right nor wrong.
- Results: 58.8% to 68.0%: held-out judged score rises at the two-epoch mark, while training reward also trends upward.The judged score is the mean trajectory reward on held-out tasks; training reward includes the dense per-step term.
8 Conclusion
Echoverse treats environments as evolving training worlds: graded rollouts reveal what to repair, while deep, capability-focused worlds and grounded reinforcement learning improve agent skills. The release includes four worlds with database-grounded graders and uncontaminated evaluation tasks.
- Conclusion: 58.8% to 68.0%: reinforcement learning against the same grounded worlds improves held-out policy performance.The loop uses graded rollouts to identify what needs fixing in the world as well as to measure the model.
- Conclusion: The central contribution is a factory that finds agent failures, builds or repairs teaching worlds, and repeats the loop rather than maximizing synthetic-site inventory.The conclusion calls for deeper closed-domain worlds, capability worlds targeting failed interactions, and more grounded reinforcement learning.
- Conclusion: Four worlds are released with environment code, graded test tasks, database-grounded verifiers, and evaluation-only tasks kept uncontaminated.The release covers ECHOSTAY, ECHOFORGE, and two capability worlds with in-distribution and held-out splits.
A Naming conventions
Echoverse worlds are behaviorally faithful clones of application classes, named for the workflows they represent rather than particular products.
- A Naming conventions: Each world clones an application class and uses the name of its represented workflow, while public benchmarks and data sources retain their real names.Public entities are cited rather than cloned.
B The supervised corpus
The supervised fine-tuning corpus is a single collection of passing GPT-5.4 rollouts used for every πSFT result, with per-world representation varying by task-set breadth and trajectory length. Failed rollouts are discarded rather than retained as negatives.
- Corpus construction: Every trajectory in the corpus is a GPT-5.4 rollout that the grounded verifier scored as passing, and this corpus supports every πSFT result in Sec. 6.The corpus is the single body of data behind the supervised fine-tuning results.
- Corpus construction: Failed rollouts are discarded instead of being retained as negative examples.Only trajectories scored as passing contribute to the supervised corpus.
- Per-world composition: Per-world counts are uneven because worlds support different numbers of task sets and require different task durations.An ECHOSTAY booking averages nearly 34 agent actions, illustrating the variation in trajectory length.
- Per-world composition: Table 10 defines task-set counts as separately exported task datasets, while steps count agent actions until termination or budget exhaustion.A trajectory ends when the agent emits terminate or exhausts its budget.
C Verifier prompts
The verifier uses separate single-call LLM judges for read and write tasks, scoring only the agent’s answer or database change against task-specific references. Read judgments allow semantic equivalence, while write judgments compare required state changes through SQL diffs and return binary verdicts with brief reasoning.
- C Verifier prompts: Each task receives one LLM comparison call, with no access to the trajectory, screenshots, or the agent’s account of its actions.The verifier instead supplies task-specific reference information and the agent’s answer or resulting database diff.
- C.1 Read tasks: Read judges compare the goal, reference answer, and agent answer for semantic equivalence.Minor formatting differences, synonyms, paraphrases, additional context, and small monetary rounding differences are accepted when meaning remains correct.
- C.2 Write tasks: Write judges compare the task goal and reference state change with the actual SQL diff between the pristine database D0 and final database DT.The diff expresses updates, inserts, and deletes that transform the before database into the after database.
- C.2 Write tasks: Write-task evaluation focuses on whether all required changes are present in the diff, while permitting additional changes and treating an empty diff as likely failure.This makes the write check assess the intended change rather than the final state alone.
- C Verifier prompts: Both read and write judges return binary JSON verdicts with a brief explanation of the comparison.Read verdicts use the reference answer and agent answer, whereas write verdicts explain which required database changes matched or did not match.
- C.1 Read tasks: Read-task judges assign 1 when the answer is semantically correct and 0 when it is completely wrong or missing key information.Each verdict is returned as JSON with exactly a score and brief reasoning.
D Capability-world widget catalogue
The capability worlds catalogue nested-filter and datepicker widget families, separating training coverage from held-out families reserved for evaluation. They span varied frontends, contexts, scenarios, and visual styles.
- Held-out widget families never appear in training and are used only for evaluation.
- Nested-filter widget families: Nested-filter training covers 20 families over 200 generated frontends in 15 visual styles, while evaluation covers 9 compound families over 100 frontends in 9 styles.
- Datepicker widget families: Datepicker training covers 6 core types over 10 contexts and 100 generated frontends in 6 visual styles, while evaluation covers 10 unusual widgets over 36 scenarios and 80 frontends in 9 styles.