acceptodds
Under review as a conference paper at ICLR 2027

CUA-Sandbox: Efficient Environments for Computer-Use Reinforcement Learning

Abstract

Reinforcement learning enables computer-use agents to improve through interaction with real software environments, including websites and desktop applications. However, conventional deployments replicate an initialized runtime for each independent rollout, even when trajectories use the same software, incurring repeated memory and initialization costs as the number of parallel environments grows. Does an independent computer-use environment require an independent execution runtime? Our key observation is that trajectories require independent mutable state, while initialized application runtimes can be reused across concurrently evolving environments, making state the natural unit of environment independence. Guided by this observation, we introduce CUA-Sandbox, which separates private state capsules from shared runtimes through state-scoped execution and transactional lifecycle operations, including resets and branches, while retaining the original software interfaces and task evaluators. Experiments show comparable or improved task success relative to Docker, while substantially reducing rollout and resource costs. CUA-Sandbox achieves up to a 6.20 increase in rollout throughput, a 9.2 reduction in per-environment memory, and a 504 reduction in incremental storage.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Computer-Use Agents

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_1KacOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes CUA-Sandbox, an environment backend for computer-use RL. Instead of running a full Docker runtime for each rollout, it shares one initialized application runtime. Each environment gets a private "state capsule": a database branch, a file overlay, and its own session and profile namespaces. Actions are routed to the right capsule by environment ID. Reset, clone and fork swap capsules by pausing the environment, finishing in-flight requests, and switching to the new capsule in one atomic step. The paper evaluates on WebArena, VisualWebArena and OSWorld. It reports task success comparable to or higher than Docker for four models, matched SFT and RL gains for a 4B student, and, at 8 concurrent environments, up to 6.20× higher throughput, 9.2× less memory and 504× less storage per environment.

Critical strengths
  1. It targets a real bottleneck with a sensible idea. RL on real software needs many independent, resettable environments, and each Docker copy re-initializes the same application. Sharing the initialized application while keeping each environment's state private is intuitive. It keeps the original interfaces and evaluators, and it avoids the sim-to-real gap of learned world models.
  2. Parts of the evaluation show where the savings come from. App. F separates the two mechanisms. Copy-on-write cuts writable storage for 8 environments from 53 to 25 GiB, and runtime sharing then cuts runtime memory 4.3× (13,882 to 3,261 MiB). A stress test shows why atomic switching matters: without it, actions saw a mix of old and new state in 100/100 trials, and with it in 0/100. RL gains also match across backends (+3.88 vs. +3.87 points on OSWorld).
Critical weaknesses

The paper doesn't show that the shared runtime behaves like the original environment.

Success shifts in one direction. A faithful backend should leave task success unchanged, up to noise. Instead, CUA-Sandbox scores higher in all 12 model–benchmark pairs (sign test p≈0.0005p \approx 0.0005), by up to 10 points. For example, Muse-Glimmer-30B goes from 24.4% to 34.4% on OSWorld. So the two backends aren't equivalent, and the paper doesn't say why. The cause isn't reported. The gap could come from Docker errors and timeouts, which the paper records (App. C) but never reports. It could also come from state leaking between concurrent environments, which would inflate success. Isolation is never tested directly. The non-DB ablation uses a read-only task, and the case studies are illustrations, not runs. In RL, 8 rollouts per task run in parallel, so a leak would silently corrupt rewards. The efficiency gains are smaller and less certain than the headline numbers.

The numbers don't agree. All three headline numbers come from the VisualWebArena column of Fig. 3. Table 6 says it lists the exact measurements behind Fig. 3, but its VisualWebArena values differ for every metric. With Table 6, memory drops 1.75×, not 9.2×, and throughput rises 4.25×, not 6.20×. The main baseline is the weakest one. The main comparisons are against plain Docker. WebServ, the closest prior system, appears only in App. A.2. Against it, launch time is about the same (1.73 vs. 1.78 s), storage is 2.2× lower, and memory isn't measured the same way for both systems. Total memory savings are about 2×. Browser and agent processes don't shrink (about 7,000 MiB for 8 environments, App. F). So total memory drops about 2.1×, while the runtime alone drops 4.8×. The RL speedup isn't measured. Efficiency is measured at 4–16 environments, but RL uses 128 per update, and the paper reports no training time or cost for either backend. In short, the idea is useful and targets a real bottleneck. But the paper doesn't yet show that the shared runtime is faithful, or how much it saves end to end. So I lean toward rejection, though clear answers to the questions below could change that.

Questions for authors

Clarifications

Why does CUA-Sandbox score higher in every pair? Please report errors and timeouts per backend, the number of runs, and how often the two backends agree on individual tasks. How do you verify isolation when concurrent rollouts of the same task make conflicting writes? Which VisualWebArena numbers are correct, Fig. 3 or Table 6? And what is the end-to-end RL training time under each backend? Suggestions

Report the engineering cost of supporting a new application, and which resources in each benchmark fell back to private backends. Show a use of fork, such as branching rollouts for tree-search RL, where cheap forks matter most.

3 comments

We thank the reviewer for the detailed assessment.

Q1. About success-rate gains.

A1: Both backends use identical timeout settings in the main evaluation. For Muse-Glimmer-30B on OSWorld, the mutually exclusive outcomes are:

Final outcomeDockerCUA-Sandbox
Success88124
Completed without task success227231
Timeout failure404
Non-timeout execution error62
Total361361

Extending only Docker's timeout increases its macro-averaged success from 24.40% to 33.70%, approaching CUA-Sandbox's 34.39%. This supports timeout sensitivity as a major contributor to the gap in this setting: lower overhead allows more tasks to finish within the budget. These results are now in Appendix B.4, Tables 11–12.

Q2. About the inconsistent VisualWebArena measurements.

A2: We apologize for this reporting error. Figure 3 is correct; we have corrected the original Table 6 (now Table 9, Appendix B.2) to match it and checked the rollout discussion. Corrected Docker / CUA-Sandbox values are: preparation 10.404 / 0.504 s; batch time 44.762 / 7.215 s; throughput 0.179 / 1.109 env/s; memory 1745.2 / 190.0 MiB; incremental storage 6503.70 / 12.90 MiB. The gains remain 6.20× throughput, 9.2× memory reduction, and 504× storage reduction.

Q3. About end-to-end RL training time and equal-time-budget performance.

A3: For Qwen3.5-4B on OSWorld, we have added the following comparison to Section 4.2, Table 3, alongside Table 2:

BackendRL timePost-RL success
Docker20 h24.97%
Docker26 h25.48%
CUA-Sandbox20 h26.04%

Under the original matched data and rollout budget, CUA-Sandbox finishes in 20 versus 26 hours, reducing time by 23.1% (1.30× speedup). At the same 20-hour budget, observed success is 1.07 points higher. Shared training settings appear in Appendix C.2, Table 13.

Q4. About isolation under concurrent state changes and resets.

A4: We have supplemented the read-only ablation with direct tests using two concurrent OSWorld environments, covering time zone, do-not-disturb mode, screen dimming, large text, and automatic screen locking, with five repetitions each.

We replay task setup and mutations deterministically, apply the original evaluators, and additionally modify identical paths under /etc and /opt, including permissions. We alternate which environment is reset. Across 25 trials, all 669 checks pass without cross-environment contamination; host/shared-base probes remain unchanged. We also check baseline restoration and a subsequent application-configuration task for residual state.

Five additional trials retain delayed writers that ignore SIGTERM and hold pre-reset file handles. No writes contaminate the successor generation; writers in the non-reset environment execute successfully as positive controls. Procedures and outcomes are now in Appendix A.3; shared/private boundaries are in Appendix D.2.

Q5. About baseline selection and the WebServ comparison.

A5: WebServ targets web-agent workloads through improved browser observation/action interfaces and Incus-based provisioning with block-level CoW. It does not directly cover OSWorld-style desktop environments. We therefore use Docker as a common reference across benchmarks and WebServ as an optimized baseline for overlapping web workloads.

The original memory entries used different accounting methods. We now compare marginal memory growth per environment for both systems, reporting mean ± standard deviation over three runs:

Resident NWebServ (MiB/env)CUA-Sandbox (MiB/env)Ratio
11750.7 ± 10.6190.7 ± 4.39.18×
41761.7 ± 13.7194.7 ± 0.49.05×
81760.6 ± 11.6195.2 ± 0.79.02×

CUA-Sandbox uses approximately one-ninth of WebServ's marginal per-environment memory. Existing measurements show comparable launch latency (1.73 vs. 1.78 s) and approximately 2.2× lower storage (12.50 vs. 28.01 MiB). Appendix A.2 now includes the scope and accounting explanations and common-metric results (Table 6); launch/storage results remain in Table 5.

Thanks for the detailed response. The corrected table and the new isolation tests address Q2 and Q4. I'm raising my score to 3, assuming the changes below go into the paper.

Success gains. The timeout breakdown explains the Muse-Glimmer-30B gap on OSWorld, but that's 1 of 12 pairs. Please report timeout counts for the other 11 pairs. Please also describe the gain as fewer timeouts rather than a better agent. Training speedup. End-to-end RL is 1.30× faster (26 to 20 hours), far below the 6.20× rollout number in the abstract. Please put 1.30× in the abstract. The 1.07-point gain at 20 hours is within noise (about 4 of 361 tasks), so I'd call it equal success in less time. Baselines. Against WebServ, memory is about 9× lower, but launch time is the same and storage is only 2.2× lower. So the 504× storage number mostly comes from copy-on-write compared with plain Docker. Please move this comparison into the main text. In short, the cost savings hold up, but the paper should claim lower cost at equal success, not higher success.

Thank you for your thoughtful feedback and for raising your score. We appreciate your careful evaluation and constructive suggestions, and will revise the paper accordingly to ensure that our claims accurately reflect the results.

Reviewer_L6VWOpenReview ↗
Rating
3
Confidence
4
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes CUA-Sandbox, an efficient execution framework for computer-use agent reinforcement learning. The key idea is to decouple mutable environment states from initialized application runtimes, allowing multiple independent rollouts to share the same runtime while maintaining isolated states. The framework introduces state capsules, state-scoped execution, and transactional lifecycle operations to support efficient environment creation, reset, and branching. Experiments on WebArena, VisualWebArena, and OSWorld demonstrate comparable task performance to conventional Docker-based environments, with up to 6.20× higher rollout throughput, 9.2× lower memory consumption, and 504× lower incremental storage.

Critical strengths
  1. The paper addresses the substantial environment overhead in large-scale computer-use RL, which is an important bottleneck for scalable agent training.
  2. Separating mutable states from shared application runtimes is a promising approach. The combination of state capsules, state-scoped execution, and transactional lifecycle management provides a coherent framework for efficient environment reuse.
  3. The authors evaluate the framework across web and desktop benchmarks, covering task success, post-training performance, rollout throughput, resource consumption, and lifecycle operations. The results demonstrate substantial efficiency improvements while largely preserving agent performance.
Critical weaknesses
  1. CUA-Sandbox relies on task resource contracts to identify mutable resources and determine which runtime components can be safely shared. However, it is unclear how these contracts are constructed in practice. Does the framework require manual, task-specific analysis to identify the sharing boundaries? What are the costs of this identification?
  2. The paper demonstrates efficiency improvements on OSWorld, but it remains unclear which runtime components are actually shared across concurrent desktop environments. Given the complexity of application-level state, window management, and display sessions, could the authors clarify which processes remain shared and which require private execution contexts?
  3. The framework assumes that all task-relevant mutable resources are covered by the resource contracts and environment-scoped bindings. How does the system ensure that these contracts are complete, especially for applications with hidden in-memory states or asynchronous background operations?
Questions for authors

see weaknesses

1 comment

We thank the reviewer for the detailed assessment.

Q1. About resource contract construction and its costs.

A1: Our OSWorld implementation combines manually maintained application specifications with automatic per-task contract compilation. The reusable specifications define application profile paths, process names, and aliases; for example, Writer, Calc, and Impress share a common LibreOffice specification. For each task, the compiler reads its related applications, setup/configuration, evaluator, and proxy information, generates a resource contract, and binds it to the corresponding environment generation.

The current implementation maintains 9 reusable application-state specifications that support automatic contract generation for all 361 tasks in our evaluation set: 272 receive fine-grained contracts, while 89 use a conservative fallback. No task requires a separately handwritten contract. Across 30 repeated measurements over the complete task set, per-task contract compilation and digest validation take a median of 0.109 ms and a P95 of 0.243 ms. Processing all 361 tasks takes a median of 41.9 ms, or 58.7 ms when including cached task-file reads and JSON parsing. Thus, manual engineering effort is concentrated in reusable application specifications and adapters, while the computational overhead of per-task contract generation is small. These timings quantify automated processing overhead, rather than human authoring effort. The construction process, coverage audit, and timing measurements are now included in Appendix D.1 of the revised PDF.

Q2. About shared runtime components and private execution contexts in OSWorld.

A2: The current OSWorld backend shares the host Linux kernel and read-only filesystem content, including the rootfs lower layer, application binaries, libraries, fonts, and benchmark/helper code. Each environment runs its own Xvfb instance, GNOME session, session D-Bus, emulated system D-Bus and timedated service, and OSWorld server. Task applications such as Chrome, LibreOffice, VS Code, and VLC run in separate per-environment processes, with their own profiles, documents, configuration, and writable filesystem state. We have made this implementation boundary explicit in Appendix D.2, Table 14, of the revised PDF; OSWorld does not share live desktop application processes across environments.

Q3. About contract completeness, hidden memory state, and asynchronous operations.

A3: We address contract completeness through explicit resource modeling and conservative isolation boundaries. Contracts combine task setup, evaluator dependencies, and reusable application-state specifications. Resources without fine-grained adapters use coarse-grained private backends, while the complete CoW filesystem captures writes beyond explicitly declared paths within its isolation boundary.

Hidden memory state remains environment-private: in OSWorld, each environment runs its own application processes and desktop session, which are stopped and recreated during lifecycle transitions. Asynchronous operations are handled through lifecycle coordination: shared-service adapters must propagate environment and generation identities and register outstanding work; before switching state, the system freezes the route and waits for registered requests and background jobs to drain. Together, these mechanisms cover both explicitly modeled resources and state enclosed within the broader private-backend boundary. We have added this explanation to Appendix D.2 and the lifecycle discussion in Appendix D.3 of the revised PDF; the direct mutation/reset tests are reported in Appendix A.3.

Reviewer_Znx7OpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

CUA-Sandbox reduces the cost of running many parallel computer-use-agent (CUA) environments for RL training and evaluation. Conventional setups give every rollout its own container or VM, even though rollouts differ only in their mutable state. CUA-Sandbox instead shares one initialized application runtime across environments and gives each environment a private state capsule. It has three components:

  1. State capsules. Each capsule handles three classes of state differently:
  • Authoritative (databases, user files): stored as copy-on-write changes on top of a shared base.
  • Derived (caches, search indexes): kept in private namespaces, and rebuilt when that is cheaper than copying.
  • Ephemeral (display, temporary connections): recreated whenever the capsule is activated.
  1. State-scoped execution. Every action carries an environment ID and a binding table that routes it to that environment's data, namespaces and endpoints. This way, shared processes read and write only that environment's state. Versioned leases reject stale requests after a state transition.

  2. Transactional lifecycle. Reset, clone and fork first freeze the environment and let in-flight requests finish. They then prepare a successor capsule and switch to it atomically. If a transition fails, the previous state stays active.

On WebArena, VisualWebArena and OSWorld, task success matches or exceeds Docker for four models, and post-training gains are the same under both backends. With eight concurrent environments, CUA-Sandbox achieves up to 6.2× higher rollout throughput, 9.2× less memory per environment, and 504× less incremental storage.

Critical strengths

- Important, well-motivated problem. Environment cost is a major bottleneck in RL training for computer-use agents. Higher rollout throughput means more experience collected under a fixed compute or wall-clock budget. This matters most for group-based methods like GRPO, which sample many rollouts from the same initial state. That is exactly where a shared runtime and cheap clone/fork help most.

- Large efficiency gains without loss of fidelity. With eight concurrent environments, CUA-Sandbox achieves up to 6.2× higher throughput, 9.2× less memory per environment, and 504× less incremental storage than Docker. Task success matches or exceeds Docker in all 12 model–benchmark pairs. Post-training gains are nearly identical under both backends (e.g., +3.88 vs. +3.87 points from RL on OSWorld).

- Ablations support the design. Removing copy-on-write makes create, checkpoint, and fork operations 57–88× slower. Without transactional publication, an environment ends up with a mix of old and new state in all 100 stress-test trials, versus none with the full protocol.

Critical weaknesses

1. Efficiency gains are not shown to improve training outcomes. The paper shows that rollouts are faster, but not that this produces a better policy. In Table 2, both backends train on the same data budget, so the experiment only shows that CUA-Sandbox does no harm. A budget-matched experiment would show the benefit: give both backends the same compute or wall-clock budget and compare final success rates. At minimum, the paper should report how long the RL runs took under each backend.

2. RL training details are incomplete. Appendix C.2 gives the batch size (16), rollout count (8), and number of training instances (1,600). It does not name the RL algorithm (e.g., PPO or GRPO), or give the optimization hyperparameters (learning rate, KL penalty, etc.). This makes the post-training results hard to reproduce. Tables 1 and 2 also report no standard deviations or number of seeds, so it is unclear whether small differences, such as 0.12 points on WebArena, are meaningful.

3. VisualWebArena rollout numbers are inconsistent. All three headline numbers in the abstract come from the VisualWebArena results in Figure 3. Table 6 claims to list the exact measurements behind Figure 3, but its VisualWebArena numbers differ and show much smaller gains:

Throughput: 0.179 → 1.109 env/s (6.2×) in Figure 3 vs. 0.220 → 0.936 env/s (4.3×) in Table 6. Memory: 1,745 → 190 MiB (9.2×) vs. 329 → 188 MiB (1.7×). Storage: 6,504 → 12.9 MiB (504×) vs. 4,879 → 12.5 MiB (390×).

Preparation and batch times differ too, while the WebArena and OSWorld numbers match. The authors should clarify which numbers are correct and update the abstract if needed.

4. Isolation is not tested for tasks that change system-wide state. Some OSWorld tasks change state for the whole operating system. For example, task b6781586 asks the agent to set the system time zone to UTC+0 (https://github.com/xlang-ai/OSWorld/blob/main/evaluation_examples/examples/os/b6781586-6346-41cd-935a-a6b1487918fc.json). The paper says that state which cannot be scoped falls back to a private backend (Section 3.2, Appendix D). However, it does not say which OSWorld tasks fall back, how often this happens, or how much of the savings remain. The isolation evidence is also limited: the non-database ablation uses a read-only task, the stress test checks timing rather than leaks between environments, and the Appendix G case studies are design illustrations, not recorded runs. The paper should report which resources are shared and which are private for each OSWorld task category. It should also test isolation directly, for example by running state-changing tasks concurrently and checking that no state leaks into other environments or later tasks.

5. Success-rate gains are unexplained. If CUA-Sandbox truly behaves the same as Docker, success rates should be about the same. Instead, CUA-Sandbox scores higher in all 12 model–benchmark pairs, sometimes by a lot. Muse-Glimmer-30B on OSWorld goes from 24.40 to 34.39, and its Professional category from 24.49 to 53.06. The paper should explain these gains, for example by checking whether they come from fewer timeouts or environment errors, or from differences in environment state.

Questions for authors

1. Isolation for system-wide state (Weakness 4). For OSWorld tasks that change OS-level state, such as task b6781586 (set the system time zone to UTC+0), what is shared and what is private? Do these tasks fall back to a private backend? What fraction of OSWorld tasks do so? Did you run any tests that check whether state leaks into other environments or later tasks? A clear answer would significantly affect my assessment.

2. RL pipeline and group rollouts. Which RL algorithm did you use? Do the 8 rollouts of a task run concurrently on the same shared runtime? This matters for group-based methods like GRPO. Each rollout's advantage is computed relative to the rest of its group. If a rollout leaks state into the others (as in the time-zone example), their rewards become correlated, and the training signal for the whole group is skewed, not just one sample's.

3. Inconsistent numbers (Weakness 3). Which VisualWebArena measurements are correct, Figure 3 or Table 6? Do the abstract's headline numbers need updating?

4. Success-rate gains (Weakness 5). Why does CUA-Sandbox outperform Docker in all 12 model–benchmark pairs, by up to 10 points on OSWorld? Do Docker runs have more timeouts or environment errors?

5 comments

We thank the reviewer for the detailed assessment.

Q1. About whether efficiency gains translate into training benefits.

A1: Thank you for this suggestion. We have added end-to-end RL times and an equal-wall-clock comparison for Qwen3.5-4B on OSWorld to Section 4.2, Table 3, of the revised PDF, supplementing the post-training results in Table 2. All final checkpoints use the same reference evaluation pipeline.

BackendRL timePost-RL success
Docker20 h24.97%
Docker26 h25.48%
CUA-Sandbox20 h26.04%

Under the original matched rollout budget, CUA-Sandbox finishes in 20 versus 26 hours, reducing time by 23.1% (1.30× speedup). At the same 20-hour budget, observed success is 1.07 percentage points higher. These results show that the system savings translate into a practical end-to-end training benefit.

Q2. About RL training details and statistical variability.

A2: Thank you for pointing out these omissions. We have added the training settings to Appendix C.2, Table 13: GSPO, AdamW, learning rate 1×10⁻⁶, KL penalty 0, clipping parameter 0.2, and weight decay 0.01, identical across backends.

For GPT-5.6-Terra, three evaluation runs with different decoding seeds give the following mean ± sample standard deviation (%), now reported in Appendix B.3, Table 10:

BackendWebArenaVisualWebArenaOSWorld
Docker21.89 ± 0.4728.34 ± 0.6867.29 ± 1.15
CUA-Sandbox22.43 ± 0.5229.06 ± 0.6170.62 ± 1.24

To further examine the small post-training difference in Table 2, we additionally report the success rates of RL-trained Qwen3.5-4B on WebArena, summarized as mean ± sample standard deviation:

BackendPost-RL WebArena success rate (%)
Docker12.91 ± 0.48
CUA-Sandbox12.97 ± 0.52

We agree that the original 0.12-percentage-point difference in Table 2 should not be interpreted as a statistically significant improvement. Section 4.2 now emphasizes comparable observed performance rather than superiority based on small differences.

Q3. About the inconsistent VisualWebArena measurements.

A3: We thank the reviewer for catching this error and sincerely apologize for the confusion. We take responsibility for the reporting inconsistency. Figure 3 contains the correct measurements. We have corrected the original Table 6 (now Table 9, Appendix B.2) to match it. The Docker / CUA-Sandbox values are: preparation 10.404 / 0.504 s; batch time 44.762 / 7.215 s; throughput 0.179 / 1.109 env/s; memory 1745.2 / 190.0 MiB; incremental storage 6503.70 / 12.90 MiB. The corresponding gains remain 6.20× throughput, 9.2× memory reduction, and 504× storage reduction.

Q4. About isolation for system-wide state changes and private-backend fallback.

A4: Our 361-task audit assigns 272 targeted contracts and 89 conservative contracts (24.7%). Desktop sessions and application processes remain private in both groups. We also generated per-task and category-level shared/private resource inventories. Across 25 trials with two concurrent environments and five system settings, 669 checks detected no cross-environment leakage. We replayed task setup and mutations, applied the original evaluators, and alternated which environment was reset. Host/shared-base probes remained unchanged. Five delayed-write trials detected no successor-generation contamination.

Median costs are CUA-Sandbox / Docker:

Contract groupSamples/backendCreate (s)Reset (s)PSS (MiB)
Targeted: 5 tasks256.60 / 16.737.15 / 20.141199 / 3132
Conservative: 4 non-time-zone tasks206.61 / 16.757.13 / 20.12870 / 2745

The procedures, outcomes, and costs are now in Appendix A.3, Table 7; the contract audit is in Appendix D.1, and shared/private resources in Appendix D.2, Table 14.

Q5. About the unexplained success-rate gains.

A5: Both backends use identical timeout settings in our main evaluation. However, environment overhead consumes part of the available time, so a slower backend may incur more timeout-related failures. For Muse-Glimmer-30B on OSWorld, extending only Docker's timeout increases its success from 24.40% to 33.70%, approaching CUA-Sandbox's 34.39%. The gap narrows from 9.99 to 0.69 points, supporting timeout sensitivity as a major contributor in this setting. We have added this control and interpretation to Appendix B.4, Table 12, of the revised PDF.

Dear Reviewer Znx7,

Thank you again for the time and effort you dedicated to reviewing our paper, as well as your constructive feedback. Following your suggestions, we have provided comprehensive additional results and follow-up discussions in our response, and we would love to engage with you further.

As the author-reviewer discussion period is coming to a close soon, we wanted to gently check in and see if our responses and new additions have addressed your concerns. If any questions remain, we would be more than happy to clarify further. We truly appreciate your time and look forward to hearing your thoughts!

Best regards, The Authors

AuthorsOpenReview ↗

Discussion follow-up for Reviewer Znx7

Dear Reviewer Znx7,

Thank you again for suggesting a comparison under the same training-time budget. We included that comparison and the end-to-end training times in our response above. If your schedule allows, we would appreciate hearing your thoughts on the revised evaluation before the discussion period closes.

Best regards,
The Authors

Comments on the paper

2 comments

Dear ACs and Reviewers,

We sincerely thank all three reviewers for their thoughtful and constructive feedback. We appreciate their recognition of the importance of reducing environment overhead for computer-use RL (Znx7, L6VW, 1Kac), the coherent framework for efficient environment reuse (L6VW), and the ablations supporting our design choices (Znx7, 1Kac).

The reviewers’ suggestions have helped us strengthen the paper. In response, we have conducted additional experiments, expanded the analyses and implementation details, and revised the manuscript. Substantive additions and modifications are marked in blue. We summarize the main concerns and what we have done below; detailed results and explanations are provided in our individual replies.

ReviewerConcernResponse
Znx7, 1KacEnd-to-end training benefits, reproducibility, and statistical variability.We added RL training-time comparisons, optimization details, and repeated evaluations. The new experiments connect environment efficiency to shorter end-to-end training and compare performance under an equal wall-clock budget. We also clarify the SFT initialization differences and distinguish evaluation variability from independent-training variability, avoiding claims of statistical superiority from small score differences.
Znx7, L6VW, 1KacIsolation under concurrent state changes and the actual sharing boundary in OSWorld.We added direct isolation tests and clarified which resources are shared or private. The tests cover concurrent mutations, conflicting writes, resets, and delayed background writes, with no contamination detected in the tested settings. The revised explanation makes the OSWorld boundary explicit and describes how private execution contexts and lifecycle coordination handle hidden state and asynchronous operations.
L6VW, Znx7, 1KacResource-contract construction, engineering effort, and conservative fallback.We added a task-coverage audit, contract-compilation measurements, and fallback-cost analysis. We explain how reusable application specifications support automatic per-task contract generation, identify the extent of conservative fallback, and separate automated processing costs from manual engineering effort. Additional measurements assess the efficiency retained on the tested conservative configurations.
Znx7, 1KacUnexplained success-rate gains and possible differences in execution behavior.We reported failure outcomes and conducted a controlled timeout experiment. These diagnostics identify timeout sensitivity as a major contributor to the observed success-rate gap in the examined setting. We clarify the scope of this evidence and distinguish observed performance differences from claims of behavioral equivalence.
Znx7, 1KacInconsistent rollout measurements and the fairness of the baseline comparison.We corrected the reporting inconsistency and added a comparison with consistent memory accounting. The revised table now agrees with Figure 3, and the associated discussion has been checked. We also clarify the scope of the WebServ baseline and compare both systems using the same memory metric, separating the new results from the original measurements that used different accounting methods.

We believe these revisions strengthen the evidence for practical training benefits and isolation, improve reproducibility, and clarify the scope of our claims. We thank the reviewers for helping us improve the paper and welcome further discussion.

Best regards,
The Authors

Area_Chair_85kWOpenReview ↗

Reminder: Reviewer Engagement During the Discussion Period

Dear Reviewers,

As the discussion period is drawing to a close, could you please review the authors' rebuttal and provide your feedback at your earliest convenience?

Active engagement in discussions with the authors is an essential part of the peer-review process and plays an important role in ensuring the success of the conference. Your participation would be greatly appreciated.

Thank you for your time and contributions.

Best regards,

AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.