Agents that operate a computer by looking at screenshots and issuing clicks and keystrokes ("computer-use agents") are mostly trained on Linux, then deployed on macOS, Windows, and Android, where they get worse. On macOS, Linux-trained agents lose between 3.23% and nearly 10% success on identical ported tasks, and model rankings flip on native macOS workflows. macOS on Apple Silicon also allows only two guest virtual machines per host, so large-scale training on that platform is expensive. In practice this pushes toward one setup: train a separate copy of the agent on each platform at whatever rate that platform allows, then combine the copies into one model. Combining weights by averaging is safe when the loss is convex. It can fail when the loss is not convex, because copies trained apart may settle into different valleys of the loss surface, and their average lands on a ridge between them. The decentralized optimization literature documents exactly this failure of consensus averaging.
This note proposes to measure whether that failure actually happens for cross-platform agents. If it does, the proposal is a training procedure that keeps per-platform copies inside one shared valley while each trains at its own pace, so that the combined model gains from transfer across platforms instead of averaging away what each copy learned. The question is cheap to answer and has a clear yes/no outcome, and the answer decides which deployment strategy is correct. If the per-platform copies are "linearly connected" (the loss stays low everywhere on the straight line between them in weight space), simple averaging is enough and nothing new is needed. If they are separated by a loss barrier, merging needs an explicit mechanism that does not rely on convexity.
Core Claim
We claim that fine-tuning a shared base agent separately on Linux, macOS, and Android produces specialists separated by a measurable loss barrier. We further claim that this barrier, and not missing knowledge alone, explains part of the transfer penalty and ranking inversion observed in MacArena. To fix it we propose anchored consensus fine-tuning. Each platform copy takes local training steps under a penalty that pulls it toward a shared anchor, and the anchor is periodically reset to the average of the copies. This lets platforms with very different compute budgets train asynchronously, and the merged model should beat both routing to specialists and naive post-hoc averaging on the data-poor platform.
For two specialists $w_a$ and $w_b$, the barrier on platform $p$ is
$$B_p(w_a,w_b)=\max_{\alpha\in[0,1]} L_p\big((1-\alpha)w_a+\alpha w_b\big)-\big[(1-\alpha)L_p(w_a)+\alpha L_p(w_b)\big],$$
where $L_p$ is held-out action-prediction loss on platform $p$ and $\alpha$ is the interpolation weight. For a convex $L_p$ the barrier is zero by definition, so a positive barrier is a direct, measurable violation of the convexity assumption that weight averaging silently relies on. During training, copy $p$ minimizes
$$L_p(w_p)+\frac{\mu}{2}\|w_p-\bar w\|^2,$$
where $\bar w$ is the anchor, reset to the mean of the copies every $K$ local steps, and $\mu$ sets how strongly copies are held together. The penalty makes each local problem better conditioned near the anchor. It does not make the problem convex, so whether it keeps the copies in one valley is an empirical claim.
Relation to Prior Work
Two papers motivate the gap. MacArena benchmarks agents on native macOS (421 tasks) and documents the transfer penalty, the ranking inversion, and the two-VM concurrency limit. It is purely diagnostic and offers no training method. The decentralized gradient-tracking line, including Balancing Communication and Computation in Gradient Tracking Algorithms for Decentralized Optimization and work by Shi Pu and Ran Xin, observes that without convexity, nodes can be pulled into different local minima and consensus averaging stops meaning anything. We treat operating systems as the "nodes" and test whether this failure appears for real agents.
Two papers supply methods. BEPA trains a screenshot-to-action policy on Linux and web environments with expert-plan assimilation and Group Relative Policy Optimization (GRPO), a reinforcement-learning method that compares groups of rollouts. We reuse it as the Linux training recipe. It never examines transfer to other operating systems, and our work starts at that point. DINGO relaxes convexity in distributed optimization by restricting attention to invex functions, where every stationary point is a global minimum. We do not assume invexity; our barrier measurement tests whether something like it holds across platforms.
Two papers constrain the design. AndroidLab shows that supervised fine-tuning on only 726 Android traces lifts open-source models from 4.59% to 21.50% average success. Per-platform supervised data is therefore powerful, and any merging scheme must not erase it. OSWorld shows that raw accessibility trees can exceed context windows and differ across operating systems. We therefore use a screenshot-only observation and a shared click, type, and scroll action space with normalized coordinates, mapping Android taps to clicks. This keeps the weight spaces comparable.
Research Program
All experiments start from UI-TARS-1.5-7B, the base model used in BEPA and MacArena.
The first stage builds three specialists from that shared base. The Linux specialist is trained with BEPA on OSWorld-Verified training tasks. The macOS specialist is trained by supervised fine-tuning on GUIrilla trajectories (27,171 tasks over 1,108 apps), with only light reinforcement learning on MacArena because of the VM limit. The Android specialist is trained on the Android Instruct Dataset.
The second stage measures $B_p$ for every pair of specialists on every platform. We use both held-out action loss and task success at five interpolation points. We then test whether barrier height predicts the drop in transfer and the ranking flips MacArena reported.
The third stage runs anchored consensus fine-tuning under realistic asynchronous budgets. Linux takes many local steps per round and macOS takes few. We sweep $\mu$ and $K$.
The fourth stage asks where the gains come from. We split MacArena into ported tasks and native tasks to test whether the merged model's improvement on macOS comes from skills shared with Linux or from preserving what the macOS copy learned.
Baselines
The naive reference is the unmodified base UI-TARS-1.5-7B evaluated zero-shot on all three platforms. It sets the floor and reproduces the transfer penalty.
The strongest existing single-platform method is BEPA. On OSWorld-Verified it raises UI-TARS-1.5-7B from 22.87% to 32.13% success, and from 5.74% to 10.30% on held-out tasks (BEPA). We rerun BEPA with its published recipe as our Linux specialist and evaluate it on MacArena and AndroidLab. On macOS, the reference strong system is OpenAI Computer Use Preview at 31.83% overall MacArena success (MacArena). It is a different, closed model, so we report it only for context. For UI-TARS on the native-macOS subset we found no reported number on Lacuna, so we will measure it.
The strongest competitor for the merging question is pooled multi-platform training. This is one model trained on the union of all three datasets with the same total gradient steps, the same tokens per platform, and the same hyperparameter-search budget (an equal number of trials) as our method.
The second competitor is a router: three specialists, with each task sent to the specialist for its operating system. Deployment always knows the OS, so this baseline is trivially available. It captures specialist quality at three times the parameter count.
The third competitor is post-hoc uniform weight averaging of independently trained specialists. It is the ablation that isolates our key ingredient: it uses the same specialists and the same compute, but has no anchor during training.
A second ablation keeps the proximal penalty but never resets the anchor. This separates the effect of pulling copies together from the effect of exchanging information between them.
Our method counts as winning if three things hold. It must exceed the router on native-macOS MacArena tasks by more than seed variance, measured over three seeds. It must stay within one point of the router on OSWorld-Verified and AndroidLab. And it must beat post-hoc averaging on every platform.
Why not just…?
Why not just pool all platforms' data and fine-tune one model? This is the real threat. Under pure supervised fine-tuning, where all data is available at once, pooling may match our method. Our argument is specific to the regime the field actually faces: reinforcement learning across platforms with unequal rollout throughput. There, pooled on-policy training must wait for the slowest platform, and macOS allows only two concurrent VMs. We run pooled training in both the supervised setting and the throughput-matched reinforcement-learning setting. If pooling matches our method in both, we report that and narrow the contribution to the barrier diagnostic.
Why not just route each task to its platform specialist? Routing preserves specialist accuracy but cannot transfer Linux-learned skills to macOS, where training data and rollouts are scarce. MacArena's ported tasks are the same as the Linux tasks, so a merged model that shares skills should do better there. Comparing the router and our method on ported versus native macOS tasks tests this directly. If the router wins on ported tasks, transfer is not happening and the claim fails.
Why not just average the specialists' weights after training? If the measured barrier is near zero, this is the right answer and our method adds nothing. The barrier experiment exists to settle that question before anything else is built. Averaging is only guaranteed to be safe under convexity, and the decentralized literature shows the failure is real in non-convex settings. Measuring the barrier is how we find out which case applies.
Why not just wait for stronger frontier models? Even strong proprietary agents reach 0% on 7+-app tasks in MyPCBench, and they still show platform-dependent ranking flips in MacArena. Scale has not removed platform specificity, and open models still need a principled way to train across platforms.
Proposed Experiments and Decisive Checks
We evaluate on three benchmarks: OSWorld-Verified for Linux, MacArena split into ported, macOSWorld, and native subsets for macOS, and AndroidLab for Android. The metric is task success, plus AndroidLab's reasonable-operation ratio. We also report held-out action loss along interpolation paths.
The first decisive check is the barrier. If $B_p$ is near zero for all pairs, specialists are linearly connected, the convexity concern is moot, and we stop after reporting that post-hoc averaging suffices.
The second decisive check is predictive. Barrier height across checkpoints and training budgets should correlate with how much averaging hurts each platform. If it does not, the basin explanation is wrong even when barriers exist.
The third check is the head-to-head comparison against pooled training, routing, and post-hoc averaging under matched compute, using the criteria in the Baselines section.
The fourth check is mechanistic. Larger $\mu$ should shrink the measured barrier between the final copies, and gains should track that shrinkage. If performance improves while the barrier stays unchanged, the benefit comes from regularization and not from keeping the copies in one valley, and we would report it as such.
References
- MacArena: Benchmarking Computer Use Agents on an Online macOS Environment
- Balancing Communication and Computation in Gradient Tracking Algorithms for Decentralized Optimization
- From Off-Policy to On-Policy: Enhancing GUI Agents via Bi-level Expert-to-Policy Assimilation
- DINGO: Distributed Newton-Type Method for Gradient-Norm Optimization
- AndroidLab: Training and Systematic Benchmarking of Android Autonomous Agents
- OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments
- GUIrilla: A Scalable Framework for Automated Desktop UI Exploration
- MyPCBench: A Benchmark for Personally Intelligent Computer-Use Agents