PaperlayerView exact revision on arXiv

Source-linked AI summary

Orchard: An Open-Source Agentic Modeling Framework

Baolin Peng, Wenlin Yao, Qianhui Wu, Hao Cheng, Xiao Yu, Rui Yang, Tao Ge, Alessandro Sordoni, Xingdi Yuan, Yelong Shen, Pengcheng He, Tong Zhang, Zhou Yu, Jianfeng Gao

arXiv:2605.15040v3cs.AIcs.CL

TL;DR

Agentic modeling lacks open, scalable infrastructure for running complex, isolated environments across domains and training stages. Orchard provides a lightweight, Kubernetes-native, harness-agnostic environment layer with reusable training recipes, achieving strong results across software engineering, GUI navigation, and personal-assistant agents, including 68.4% average GUI success.

  • Problem

    Scaling agentic training and evaluation requires open, affordable infrastructure that can concurrently provision and manage isolated environments with diverse requirements.

  • Method

    Orchard combines a thin, reusable Kubernetes-native environment service with agentic modeling recipes spanning software engineering, GUI navigation, and personal-assistant agents.

  • Results

    Across software engineering, GUI navigation, and personal-assistant workflows, Orchard achieves strong results, including 68.4% average success across three GUI benchmarks.

  • Takeaways & Limitations

    A shared, open, harness-agnostic environment layer supports reusable agentic data, training recipes, and evaluation protocols across domains and pipeline stages.

  • Takeaways & Limitations

    Orchard assumes environment management can remain a thin standalone service decoupled from agent harnesses, model serving, and training orchestration.

Abstract

from arXiv · show

Agentic modeling aims to transform LLMs into autonomous agents capable of solving complex tasks through planning, reasoning, tool use, and multi-turn interaction with external environments. We present Orchard, an open-source framework for scalable agentic modeling. At its core is Orchard Env, a lightweight Kubernetes-native environment service that provides reusable primitives for sandbox lifecycle management across task domains, agent harnesses, and training stages. On top of Orchard Env, we build three agentic modeling recipes. Orchard-SWE targets software engineering agents. We introduce credit-assignment supervised fine-tuning and a progression of RL signals: Balanced Adaptive Rollout (BAR) for sparse-reward optimization, on-policy distillation (OPD) and rubric-based process reward (RPR) for dense supervision, and historical experience distillation, which compresses rollouts from prior experiments into a compact value model for inference-time reranking. Built on the Qwen3.5-35B-A3B backbone, Orchard-SWE reaches 69.7% with RPR-based RL and 73.0% with value-model reranking on SWE-bench Verified, setting a new state of the art among open-source methods while approaching frontier systems over 10x larger. Orchard-GUI trains a 4B vision-language computer-use agent using only 0.4K distilled trajectories and 2.2K open-ended tasks, achieving 68.4% average success across WebVoyager, Online-Mind2Web, and DeepShop, making it the strongest open-source model while remaining competitive with proprietary systems. Orchard-Claw targets personal assistant agents. Trained with only 0.2K synthetic tasks, it achieves 59.6% pass@3 on Claw-Eval and 73.9% when paired with the stronger ZeroClaw harness. Collectively, these results demonstrate that a lightweight, open, harness-agnostic environment layer enables reusable agentic data, training recipes, and evaluation protocols across domains.

1 Introduction

Orchard presents an open framework for scalable agentic modeling centered on a thin, reusable, Kubernetes-native environment service. Its shared infrastructure and training recipes transfer across task domains, agent harnesses, and pipeline stages, supporting strong results in software engineering, GUI, and personal-assistant agents.

  • Orchard-SWE: 73% on SWEbench Verified is achieved by Orchard-SWE with a 35B-A3B model, approaching frontier MoE systems 10–30× larger.Its recipe addresses limited supervision and sparse rewards through credit-assignment SFT and progressively denser RL signals.
  • Orchard framework: The thin environment boundary makes trajectory data, SFT and RL recipes, rollouts, and evaluation protocols reusable across domains, harnesses, and pipeline stages.This design addresses the environment layer’s role as a foundational bottleneck for scalable, reproducible agentic modeling.
  • Orchard framework: Orchard Env provides harness-agnostic, Kubernetes-native primitives for sandbox lifecycle management, command execution, file I/O, network policy, and REST access.The service is decoupled from agent harnesses, trainers, inference backends, and task domains.
  • Orchard-GUI: 68.4% average success is achieved by the 4B vision-language Orchard-GUI across WebVoyager, Online-Mind2web, and DeepShop.The benchmark success rates are 74.1%, 67.0%, and 64.0%, respectively.
  • Orchard-Claw: 73.9% pass@3 is achieved by Orchard-Claw when paired with the stronger ZeroClaw harness at inference time, despite using only 0.2K synthetic tasks.The same model achieves 59.6% pass@3 on Claw-Eval without that stronger harness.

2 Orchard Env

Orchard Env is a lightweight, Kubernetes-native environment service designed as a thin, reusable boundary across agent harnesses, trainers, and task domains. Its direct sandbox execution path provides low latency, reliability, and cost-practical scaling on standard cloud infrastructure.

  • Design requirements: Orchard Env isolates environment management from agent harnesses, model serving, and training so different trainers, agent designs, and task domains can share one service.It is designed as a thin standalone service boundary with low-cost support for heterogeneous environments and arbitrary Docker images.
  • Architecture: The three-layer architecture combines synchronous and asynchronous Python clients, a Kubernetes-based orchestrator, and a lightweight in-pod agent injected into each sandbox.The orchestrator handles lifecycle and scheduling, while the in-pod agent handles command, file, and health requests.
  • Cost: $673 with spot instances is the estimated cost for 128 parallel sandboxes over 240 hours, enabled by self-hosted Kubernetes, spot capacity, and autoscaling.The workload uses 2 vCPU and 8 GiB per sandbox.
  • Performance: 0.28 s average execution latency matches SkyPilot Code Sandbox at 0.284 s and beats E2B at 0.747 s and Modal at 2.046 s.Direct Pod-IP communication bypasses the Kubernetes API server on the hot path.
  • Reliability and throughput: 100% success across 1,000 sessions completed in 26 seconds, sustaining roughly 154 commands per second across the create →exec →delete lifecycle.The sessions had no failures in creation, execution, or cleanup.
  • Performance: Orchard Env matches direct Docker performance within run-to-run variance across three Terminal-Bench 2.0 models, with a marginal 1–2 point edge in every case.The comparison averages three independent runs per model-backend pair.

3 Orchard-SWE … 3.4 On-policy Learning

Orchard-SWE is a two-stage, environment-grounded training recipe for software-engineering agents: credit-assignment SFT on curated trajectories followed by RL with adaptive sampling and dense rewards. Its open dataset and RL methods target long-horizon SWE-bench tasks through reusable sandboxed interactions.

  • 3 Orchard-SWE: Orchard-SWE trains software-engineering agents with supervised fine-tuning on teacher-distilled trajectories followed by reinforcement learning using environment-grounded rewards.The agent solves GitHub issues by producing patches that must pass the associated gold test suite, evaluated primarily on SWE-bench Verified’s 500 human-validated instances.
  • 3.1 Problem Setting: The agent operates in a multi-turn ReAct loop with shell execution, file viewing and editing, and patch submission routed through isolated Orchard Env sandboxes.Each task runs in a sandbox provisioned with 2 vCPUs and 8 GiB memory.
  • 3.2 Trajectory Collection and Curation: 107K trajectories spanning 19,287 task instances form the released Orchard-SWE dataset, including 74.6K resolved and 32.5K unresolved trajectories.Trajectories average 47.5 interaction turns and approximately 21K tokens; unresolved trajectories provide partial-progress supervision rather than being discarded.
  • 3.3 Off-policy Learning: Supervised Fine-Tuning with credit assignment: Credit-assignment SFT uses resolved trajectories for imitation and extracts positive-progress rise segments from unresolved trajectories for exploration-focused supervision.A retrospective teacher value curve is inverted-U in 98.9% of annotated cases, typically peaking during exploration and declining near failed submission.
  • 3.4.1 Reinforcement Learning with Balanced Adaptive Rollout (BAR): Balanced Adaptive Rollout (BAR) generates per-prompt trajectory strides until it assembles a fixed-size group with a target positive-reward fraction, avoiding wasted zero-variance rollouts.It early-stops on balanced groups, continues sampling difficult prompts within a maximum budget, and uses relaxed or best-effort fallback selection when necessary.
  • 3.4.3 Denser Reward: Rubric-based Process Reward (RPR): Rubric-based Process Reward (RPR) scores whole trajectories on process quality, emphasizing self-verification independently of whether the final tests pass.Its seven dimensions include fix quality and verification behavior, with self-verification dimensions R2–R7 receiving total weight 0.85.

3.5 Distilling Historical Rollouts into a Value Model … 3.8 Ablations and Analysis

Across Sections 3.5–3.8, Orchard-SWE turns historical agent trajectories into an offline value model that improves inference-time selection, while broader training diversity supports strong results and generalization across harnesses and tasks. Ablations show that data scale, harness choice, credit-assignment SFT, and reinforcement learning materially shape performance.

  • 3.5 Distilling Historical Rollouts into a Value Model: Historical experience distillation compresses heterogeneous, environment-grounded rollouts from prior policies into a reusable value model for new-policy trajectories.The approach tests whether solution-quality structure transfers across policy distribution shift rather than remaining specific to source policies.
  • 3.6 Main Results: 45.5 absolute points lift Qwen3-30B-A3B-Thinking from 22.0% to 67.5% after SFT+RL, exceeding several comparable or larger open baselines.The same recipe matches Scale-SWE-Agent under SFT and outperforms it under SFT+RL.
  • 3.6 Main Results: 69.7% resolve rate is achieved by RPR on Qwen3.5-35B-A3B, improving over BAR’s 69.1% and OPD’s 69.3%.BAR raises the 61.4% base by 7.7 points, while OPD avoids outcome-verification rollouts and lowers rollout cost.
  • 3.6 Main Results: 73.0% resolve rate results from best-of-6 reranking of the 69.7% RPR policy with a small 4B value model trained offline on prior experiments.An oracle reaches 82.4%, leaving 12.7 points of inference-time selection headroom.
  • 3.7 Generalization to Unseen Harnesses and Tasks: 45.0–64.3% resolve rates across three harnesses show Orchard-SWE generalizes more robustly than models that produce invalid outputs or collapse under harness changes.OpenSWE-32B falls from 62.4% natively to 3.6% on Kimi-CLI, while Scale-SWE yields no measurable rate outside its native harness.
  • 3.7 Generalization to Unseen Harnesses and Tasks: 20.1% resolve rate on Terminal-Bench 2.0 under Kimi-CLI demonstrates non-trivial out-of-domain capability, versus 0.0% for OpenSWE-32B.On SWE-bench Multilingual, Orchard-SWE drops 13.3 absolute points from Verified, roughly half OpenSWE-32B’s relative decline.
  • 3.8 Ablations and Analysis: +8.2-point gain from 512 to 2048 trajectories on Diverse repo shows data scale dominates selection strategy, while selection-strategy spread shrinks as N increases.Large diff leads at N = 512 with 49.5 but gains only +0.7 points from N = 1024 to N = 2048.
  • 3.8 Ablations and Analysis: 53.5–57.9% matched-harness resolve rates collapse to 19.0–28.0% when evaluated under a mismatched harness, revealing severe harness coupling.The ablations also isolate credit-assignment SFT and compare reinforcement learning from moderate and heavy SFT checkpoints through scale-matched controls.

4 Orchard-GUI

Orchard-GUI applies a generic, harness-agnostic ReAct loop and two-stage training recipe within Orchard Env to train a 4B GUI agent. It achieves 68.4% average success across three benchmarks, with RL providing the main performance gains and strong generalization on diverse websites.

  • Agent formulation: Orchard-GUI uses a generic multi-turn ReAct-style loop instead of a bespoke browser-agent harness, enabling a unified agentic-learning paradigm across domains.The agent operates through a fixed 13-tool OpenAI tool-calling action space executed in Orchard Env.
  • Data construction: 15,601 filtered seed tasks produced 62,395 teacher rollouts for the SFT/RL dataset, using Qwen3-VL-235B-A22B-Thinking as the sole teacher.The pipeline filtered 292,092 raw WebGym instances before trajectory sampling and judge-based curation.
  • Main results: 68.4% average success: Orchard-GUI reaches 74.1% / 67.0% / 64.0% on WebVoyager / Online-Mind2Web / DeepShop.This is reported as the strongest open-source result by a wide margin, using a 4B backbone and only 2.6k training tasks.
  • Training effects: +13.9 / +20.0 / +15.3 absolute points: RL lifts the SFT checkpoint across WebVoyager / Online-Mind2Web / DeepShop, from 52.0% →68.4% average.The SFT-initialized RL policy also generalizes more strongly and optimizes more stably than RL initialized directly from the base model.
  • Generalization: +31.7 and +21.7 absolute points: Orchard-GUI surpasses MolmoWeb-8B on Online-Mind2Web and DeepShop, and exceeds its 235B teacher by +3.3 / +7.3.The largest gains occur on Online-Mind2Web, whose broader website distribution requires generalization to previously unseen interfaces.

5 Orchard-Claw

Orchard-Claw applies Orchard’s two-stage SFT-plus-RL recipe to multi-step daily workflows evaluated with Claw-Eval. It achieves 59.6% pass@3 on the native harness and 73.9% with ZeroClaw, using only 0.2k synthetic tasks.

  • Task and evaluation: Orchard-Claw targets multi-step daily workflow tasks requiring safe, robust interaction with diverse tools, evaluated by auditing the complete agent trajectory.The benchmark example involves sorting inbox messages using Gmail tools.
  • Data generation: Synthetic data begins from Claw-Eval and ClawHub seeds, with Opus 4.6 synthesizing tasks and MiniMax-M2.5 generating five candidate rollouts per task for filtering.Only trajectories that complete each task are retained for SFT.
  • Training recipe: Training uses teacher-distilled supervised fine-tuning followed by reinforcement learning, with Orchard Env as the execution backend and Qwen3-30B-A3B-Thinking-2507 as backbone.RL uses binary environment-grounded rewards and standard GRPO for 150 training steps.
  • Main results: 31.7% pass3 and 59.6% pass@3 are achieved on Claw-Eval’s native ReAct-style harness after two-stage training on only 0.2k synthetic tasks.The model surpasses its backbone and specialized Qwen3-Coder-30B-A3B-Instruct and Nemotron-3-nano-30b-a3b models.
  • Cross-harness evaluation: 41.0% pass3 and 73.9% pass@3 result when Orchard-Claw is paired with ZeroClaw, improving over ReAct-style execution by +9.3 and +14.3 absolute points.This is the largest harness-switching gain among the compared models.

6 Related Work

Related work frames agentic training around interactive environment orchestration, contrasting integrated training stacks with decoupled environment services. It also situates Orchard’s software-engineering, GUI, and Claw-agent settings within established benchmarks and evolving training paradigms.

  • Interactive environment orchestration: Interactive agentic training requires isolated environments that support action execution, feedback processing, and multi-turn trajectory iteration.The infrastructure is organized around two paradigms: integrated training stacks and decoupled environment services.
  • Interactive environment orchestration: Integrated stacks co-design execution environments with particular training frameworks or agent harnesses, limiting composition with arbitrary external systems.MegaFlow and ProRL Agent illustrate increasing but incomplete separation between environment execution, rollout generation, and training.
  • Interactive environment orchestration: Decoupled environment services expose thin APIs reusable across training frameworks, agent scaffolds, and task domains, while commercial platforms primarily target developer-facing sandboxing and code execution.E2B, Daytona, and Modal exemplify this service-oriented approach through REST APIs or SDKs.
  • Software engineering agents: Software-engineering agents commonly receive a GitHub issue and repository snapshot and must produce a patch passing its tests, with SWE-bench and SWE-bench Verified serving as primary benchmarks.These benchmarks operationalize the canonical software-engineering task formulation used to evaluate Orchard-SWE.
  • GUI and browser navigation agents: GUI-agent evaluation spans structurally distinct live web tasks, and Orchard-GUI uses WebVoyager, Online-Mind2Web, and DeepShop as a demanding unified-model testbed without benchmark-specific tuning.The benchmarks differ in task structure, action spaces, and reward signals.
  • Generalist long-running autonomous agents (Claw-agent): Claw-style agents emphasize persistent state and identity, dynamic skills, heterogeneous API workflows, and proactive heartbeats rather than episodic domain-specific tools.Claw-Eval assesses long-term planning and tool-calling stability, while ClawGym uses automated synthesis over mock workspaces for scalable data generation.

7 Conclusion

Orchard is an open-source framework for scalable agentic modeling built around a thin, Kubernetes-native, harness-agnostic environment service. By decoupling sandbox management from agent harnesses, trainers, and task domains, it makes agentic research more reusable, reproducible, cost-effective, and accessible.

  • Framework: Orchard centers on a thin, Kubernetes-native, harness-agnostic environment service for scalable agentic modeling.This environment layer decouples sandbox management from agent harnesses, trainers, and task domains.
  • Framework: Decoupling sandbox management makes trajectory collection, SFT, RL rollouts, and evaluation more reusable, reproducible, and cost-effective.
  • Impact: Orchard lowers the barrier to open, reproducible, capability-focused research in agentic AI across domains and harnesses.

A Orchard Env Design Details

Orchard Env is designed as a thin, reusable environment layer that supports diverse training recipes, agent harnesses, and model backends while providing isolation and lifecycle management. Its Kubernetes-native design uses lightweight mechanisms for agent injection, communication, isolation, readiness, and cleanup.

  • Design principle: Orchard Env prioritizes reusability across training recipes, agent harnesses, and model backends while retaining isolation and lifecycle management for large-scale agentic training.These design choices are intended to satisfy requirements R1–R3.
  • Agent injection: A Kubernetes init container injects a self-contained Python runtime and agent server into diverse task images through a shared emptyDir volume.This avoids modifying each base image to include an execution agent.
  • Communication: Direct pod-IP routing bypasses the Kubernetes API server and WebSocket-based exec setup, reducing per-command round-trip overhead and avoiding a control-plane throughput bottleneck.All execution and file-operation requests use the pod IP after sandbox provisioning.
  • Network isolation: NetworkPolicy-based isolation applies namespace-wide default-deny egress, with temporary per-sandbox exceptions for required network access.Per-sandbox policies are cleaned up with the sandbox, providing defense-in-depth against attempted data exfiltration.
  • Lifecycle management: Asynchronous creation, heartbeat-based retention, and background expiration cleanup decouple API responsiveness from scheduling latency while preventing resource leakage.Clients can poll or block on /wait until readiness, and expired heartbeats trigger sandbox deletion.
  • Readiness: A persistent Kubernetes LIST+WATCH stream tracks sandbox pod transitions in real time, caches state in memory, and notifies waiters without repeated polling.Waiters are notified through asyncio.Event.

B Cost Analysis Details

The cost analysis models 128 parallel 2-vCPU, 8-GiB sandboxes running for 240 hours and compares Orchard’s self-hosted deployment with managed services. Orchard reduces costs through spot instances, VM multiplexing, and cluster-level control.

  • Scenario: 128 parallel sandbox environments are estimated for 240 hours, with each configured at 2 vCPUs and 8 GiB RAM.This matches a typical SWE-bench task environment.
  • Orchard setup: Orchard deploys 17 Azure Standard_D16ads_v5 instances, with 16 nodes hosting 8 sandboxes each and 1 node running the orchestrator.Sandbox nodes use spot instances, while the orchestrator uses standard pay-as-you-go pricing.
  • Spot-instance economics: ∼80% discount brings D16ads_v5 spot pricing to ∼$0.165/hr versus $0.824/hr on-demand, making preemptible instances suitable for recreatable ephemeral sandboxes.Managed services cannot pass through spot pricing because they control the underlying infrastructure.
  • VM-level multiplexing: Orchard’s VM-level multiplexing shares overhead across 8 sandboxes per D16ads_v5 node, unlike MegaFlow’s one-task-per-instance model.MegaFlow allocates a full VM to each sandbox, leading to higher per-sandbox cost even with comparable cloud pricing.
  • On-demand comparison: $3,362 is Orchard’s on-demand cost, roughly half of E2B and Daytona at $7,078 each and one-third of Modal at $10,305.Orchard also gives researchers control over node pools, autoscaling, network policies, and resource limits.
  • Research-scale workloads: Thousands of hours of environment interaction for 160K rollout trajectories, ablations, and training iterations can be practical for academic research budgets with Orchard’s spot-friendly design.The analysis notes that these cost differences compound over a research project.

C Orchard RL Implementation Details

Orchard’s RL implementation extends slime with an asynchronous, Ray-orchestrated architecture that decouples training, inference, and execution services. Pipelining and fault-tolerant rollout handling improve throughput and reliability during agentic RL.

  • System Design and Component Orchestration: 0.28 s per command is Orchard Env’s execution latency, which directly supports RL throughput because each rollout requires dozens of environment interactions.The passage identifies sandbox responsiveness as critical for scaling training throughput.
  • System Design and Component Orchestration: The RL system extends slime’s Ray-based, Megatron-LM-backed training and SGLang-based inference architecture into four loosely coupled, independently scalable services.Services communicate through Ray actor handles and HTTP endpoints, enabling components to be scaled, replaced, or restarted independently.
  • System Design and Component Orchestration: The policy trainer uses Megatron-LM with tensor, pipeline, expert, and context parallelism to optimize advantage-weighted policy gradients.The rollout inference service serves the latest policy snapshot with KV-cache reuse, deterministic seeds, and per-token log-probability extraction.
  • System Design and Component Orchestration: Asynchronous pipelining overlaps weight updates for rollout k with generation for rollout k+1, while partial trajectory failures are contained so sandbox errors do not crash optimization.A central rollout manager coordinates dispatch and robust handling of incomplete trajectories.
  • System Design and Component Orchestration: A multi-layer timeout and retry hierarchy bounds tail latency across sandbox, inference, observation, shutdown, and reward-evaluation stages while preserving end-to-end reliability.Resource-exhaustion crashes trigger automatic CPU and memory escalation on retry, with jitter before sandbox creation to reduce thundering-herd effects.

D Orchard-SWE Prompt List

The Orchard-SWE prompt list defines retrospective credit assignment for failed coding trajectories and process-reward grading for agent behavior. It combines checkpoint-level success probabilities with seven evidence-based dimensions emphasizing self-verification quality and responses to test evidence.

  • Credit Assignment: P(resolve) is estimated retrospectively at every checkpoint by reasoning backward from the known failure and lowering probability at or before the critical mistake.The prompt requires probabilities to rise during correct exploration, drop at the critical error, and remain low through submission.
  • Credit Assignment: Calibration starts at 0.3–0.5, requires a drop at the critical error, and sets the final-step probability below 0.2 without monotonic increases.The examples illustrate values such as 0.40, 0.50, 0.25, and 0.10 across trajectory steps.
  • Process Reward Grading: Process quality is scored on seven 0.0–1.0 dimensions, with R1 evaluating the patch and R2–R7 evaluating the agent’s self-verification using concrete trajectory evidence.Scores are combined by weighted average, while each dimension is judged independently of whether the tests ultimately passed.
  • Process Reward Grading: Self-test relevance receives the strongest score when tests reproduce the bug before the fix and re-check the exact required behavior afterward.The rubric distinguishes absent or weak reproductions from direct, issue-targeted checks and separately evaluates scenario breadth and assertion strength.
  • Process Reward Grading: Verification integrity penalizes ignored failures, no-op commands, or submission without verification, while full credit requires real green checks and acting on failures.The grading principle penalizes mishandling evidence rather than merely the presence of error strings during exploration.

E Orchard-SWE RPR Rubrics and Curves

Orchard-SWE’s RPR rubric emphasizes self-verification, while process-reward metrics consistently improve throughout RL training. The rubric combines patch grading with reference-guided self-verification criteria.

  • RPR rubric: 0.85 of the rubric weight is assigned to self-verification quality through criteria R2–R7, while R1 grades the patch.The seven rubric weights sum to 1.
  • Training curves: All tracked process-reward metrics trend upward during RL training, including fix quality, self-test relevance, coverage, regression guard, verification integrity, and their mean.These metrics are evaluated using an LLM-as-a-Judge process reward.

F Orchard-GUI Tool List

Orchard-GUI exposes 13 atomic tools through OpenAI tool-call JSON Schemas, organized into families covering pointer, keyboard, page-navigation, tab-management, and task-completion actions.

  • Tool organization: 13 atomic tools are defined as OpenAI tool-call JSON Schemas and grouped by family for readability.Each step emits one or multiple tool calls inside <tool_call>...</tool_call> blocks.
  • Pointer Actions: Pointer Actions provide click, hover, and drag operations using screen coordinates.Click accepts [x, y] viewport coordinates, hover triggers interface states at a coordinate, and drag moves between starting and ending coordinates.
  • Keyboard Actions: Keyboard Actions provide write and press_keys for entering text, navigation, shortcuts, and discrete key presses.write clears the focused field before typing, while press_keys supports simultaneous or sequential key presses and repeated presses.
  • Page-Navigation Actions: Page-Navigation Actions provide scroll, goto_url, go_back, and wait for page movement, direct URL navigation, history navigation, and loading delays.scroll can target the main page or a coordinate-specific scrollable element, while wait allows content or animations to complete.
  • Tab-Management Actions: Tab-Management Actions provide new_tab, switch_tab, and close_tab for creating, selecting, and closing browser tabs.switch_tab uses a 0-based tab index, while new_tab opens a blank tab and close_tab selects a remaining nearby tab when applicable.
  • Task completion: The done tool signals task completion, failure, or CAPTCHA blockage and requires a concise explanatory response.Its response summarizes accomplished actions, results, or the reason progress could not continue.

G Example GUI Agent Trajectory

The appendix presents a representative Orchard-GUI WebVoyager-style rollout, showing the full seven-cycle interaction from accumulated context and image input through reasoning, tool calls, observations, and task completion. The agent completes an Amazon search for a washable dog bed at least 30 inches long, identifying a 35-inch candidate.

  • Trajectory overview: The appendix shows a full seven think →tool_call →tool_response cycles rollout produced by Orchard-GUI on a WebVoyager-style task.The final-step input includes the system prompt and accumulated trajectory through prior steps, with one context image.
  • Agent interface: The GUI agent receives action history, the user request, and webpage observations including tabs, screenshots, and optionally an accessibility tree.Its available browser actions include mouse and keyboard interactions, navigation, tab management, task completion, and waiting.
  • Agent protocol: The agent must begin with <think>, emit valid executable <tool_call> blocks, and execute multiple calls sequentially when a task step requires a short action chain.The reasoning is instructed to assess the current state, reflect on prior actions, plan safely, and consider alternatives when progress stalls.
  • Task execution: The rollout starts by clicking Amazon’s “Continue shopping” verification button, then focuses the search bar to begin searching for a washable dog bed at least 30 inches long.The tool response reports successful execution of the verification-page click and search-bar click without navigation or a new tab.
  • Task outcome: 35 inches: the EHEYCIGA Washable Large Dog Bed (35x23 Inch) satisfies both requirements because it is washable and exceeds the 30-inch minimum length.The product title and size specifications confirm dimensions of 35" x 23" x 3.5".

H Orchard-GUI Task Filtering Pipeline

Orchard-GUI constructs an evaluation-safe, diverse training pool from 292,092 WebGym task instances through a five-stage filtering pipeline. The final 15,601 unique task intents seed teacher trajectories for SFT and RL prompts.

  • Pipeline overview: 292,092 raw WebGym task instances enter a five-stage filtering pipeline designed to produce a clean, evaluation-safe, and diverse training-prompt pool.The pipeline operates on task instances organized by WebGym.
  • Benchmark decontamination: 13,840 overlapping instances are removed, reducing the pool from 292,092 to 278,252 while retaining the complementary PAE-WebVoyager and InSTA-v3 splits.This step removes overlap with held-out Online-Mind2Web and DeepShop benchmarks to prevent train/test contamination.
  • Final task pool: 15,601 unique task intents remain as the seed set for sampling teacher trajectories for SFT and RL prompts.The filtered intents support downstream supervised fine-tuning and reinforcement-learning prompt construction.

I Example Claw Agent Trajectory

The example ZeroClaw trajectory shows an assistant configured for direct tool use and structured JSON function calls. Given a multi-step inventory-rotation request, it identifies the required actions and begins by querying the inventory list.

  • Harness configuration: ZeroClaw is instructed to use available tools directly while remaining concise and helpful.The system prompt explicitly frames the model as an AI assistant with tool access.
  • Harness configuration: Each function call must be emitted as a JSON object containing the function name and arguments inside <tool_call> XML tags.The example specifies the required serialization format for tool invocations.
  • Task execution: The user asks the agent to review emails and inventory, identify critical or expiring items, contact suppliers, schedule weekly follow-ups, and save a rotation-plan summary.The request includes supplier-contact lookup and a target file path: /home/user/rotation_plan.txt.
  • Task execution: The assistant operationalizes the request by applying a 45-day expiry window, grouping supplier quote requests, prioritizing items above $1000, and starting with an inventory query.It first calls inventory_list_products with no arguments after stating the interpreted requirements.
Loading 2605.15040v3…