OSWorkerBench

OSWorkerBench is an office-centric desktop GUI-agent benchmark introduced in UI-Mate: Advancing Open-Weight Foundation GUI Agents with In-Context Demonstrations. It contains 100 long-horizon tasks across 17 business tracks and 41 applications, with executable evaluators and demonstration-guided evaluation.

See the Hugging Face paper page and the benchmark implementation.

Load with Datasets

The default tasks configuration contains one row per benchmark task:

from datasets import load_dataset

dataset = load_dataset("tencent/OSWorkerBench")
first_task = dataset["test"][0]

The demonstrations configuration exposes the released self-demonstrations as one row per recorded GUI step:

demonstrations = load_dataset("tencent/OSWorkerBench", "demonstrations")
first_step = demonstrations["test"][0]

Run an evaluation

load_dataset() loads the task and demonstration tables for inspection and analysis. Executing the benchmark requires the UI-Mate evaluation harness, an Ubuntu Docker VM, the mock applications, and an OpenAI-compatible model endpoint. The supported entry points are the two Bash launchers in the GitHub repository; they prepare assets, validate the task/cache pairing, start or reuse vLLM, run the environments, retry missing results, and print an aggregate score.

1. Requirements

• A Linux host with Docker support. The released VM provider supports Ubuntu.
• Python 3.9 or newer.
• Node.js 20, npm 10, and tmux for the 98 mock applications.
• Enough disk space for the 27.45 GB qcow2 VM, model weights, videos, and run artifacts.
• For local inference, GPUs supported by vLLM. The default UI-Mate configs use tensor parallel size 2; edit the YAML or provide an existing endpoint if your deployment differs.
• A mock host whose ports 8100-8197 are reachable from every benchmark VM.

2. Clone and install the harness

git clone https://github.com/Tencent/UI-Mate.git
cd UI-Mate/osworker_bench

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

The package alternative is:

pip install -e ".[full]"

Log in to Hugging Face before downloading private datasets or gated models:

hf auth login
hf auth whoami

3. Deploy the mock applications

The mock stack is a separate service; the benchmark launcher does not start it. Deploy it on a host accessible from the Ubuntu VMs:

cd CUA-Gym-Hub
BASE_PORT=8100 bash deploy-all.sh --no-attach
cd ..

The bundled deployment script sorts all *_mock directories deterministically and maps them to ports 8100-8197, matching .MOCK_HOST. Confirm that the first and last ports are reachable from the evaluation host and from inside the VM. MOCK_APP_BASE_URL must contain only the scheme and host, with no port or path, for example http://mock-host.example.

4. Configure the run

You can copy the environment template and set the mock host:

cp .env.example .env

At minimum, configure:

MOCK_APP_BASE_URL=http://mock-host.example

Do not commit .env or access tokens. The main configurations are:

• configs/osworker_benchmark/ui_mate.yaml: 100 instruction-only tasks using tencent/UI-Mate-27B, up to 200 steps per task.
• configs/osworker_benchmark/ui_mate_democua.yaml: 33 self-demo tasks using tencent/UI-Mate-democua-27B, up to 500 steps per task.

5. Run a one-task smoke test

Before launching all 100 tasks, verify the VM, mock host, model endpoint, and evaluator with a one-task manifest:

printf '{"ae":["ae_contract_signature_001"]}\n' > /tmp/osworker-smoke.json

MOCK_APP_BASE_URL=http://mock-host.example \
BENCHMARK_META=/tmp/osworker-smoke.json \
NUM_ENVS=1 \
MAX_STEPS=30 \
bash scripts/osworker_benchmark/start_osworker_benchmark_test.sh

This short run is an infrastructure check; its task score is not comparable to the full evaluation because of the reduced step budget.

6. Run the full 100-task benchmark

MOCK_APP_BASE_URL=http://mock-host.example \
bash scripts/osworker_benchmark/start_osworker_benchmark_test.sh

On the first run, the launcher:

1. downloads tencent/UI-Mate-27B unless MODEL_PATH or an endpoint is given;
2. downloads the pinned Ubuntu qcow2 and benchmark cache when absent;
3. synchronizes mock endpoints using .MOCK_HOST;
4. validates all manifest, task JSON, and cache-directory IDs;
5. starts/reuses Docker and vLLM; and
6. evaluates all 100 tasks with 10 parallel environments by default.

Useful overrides:

MOCK_APP_BASE_URL=http://mock-host.example \
NUM_ENVS=4 \
MAX_STEPS=200 \
REPEAT_RUNS=3 \
MODEL_PATH=/path/to/model \
bash scripts/osworker_benchmark/start_osworker_benchmark_test.sh

To reuse an existing compatible vLLM server, pass host:port. The default instruction-only config expects the served model name UI_Mate:

MOCK_APP_BASE_URL=http://mock-host.example \
VLLM_ENDPOINT=10.0.0.20:8081 \
bash scripts/osworker_benchmark/start_osworker_benchmark_test.sh

7. Run the 33-task DemoCUA evaluation

Run the instruction-only launcher once first so the shared docker_vm_data/Ubuntu_openpyxl.qcow2 is available, then point the DemoCUA launcher to that VM:

MOCK_APP_BASE_URL=http://mock-host.example \
OSWORLD_VM_SOURCE_PATH="$PWD/docker_vm_data/Ubuntu_openpyxl.qcow2" \
bash scripts/osworker_benchmark/start_osworker_benchmark_democua_test.sh

To reuse an existing endpoint, its served model name must match MODEL_NAME:

MOCK_APP_BASE_URL=http://mock-host.example \
OSWORLD_VM_SOURCE_PATH="$PWD/docker_vm_data/Ubuntu_openpyxl.qcow2" \
VLLM_ENDPOINT=10.0.0.20:8081 \
MODEL_NAME=UI_Mate_DemoCUA \
bash scripts/osworker_benchmark/start_osworker_benchmark_democua_test.sh

The launcher verifies that all 33 target tasks have a corresponding trajectory_captioned.json. A missing demo would otherwise silently turn that case into an instruction-only run and make results incomparable.

8. Use this repository's mirrored task cache

The GitHub launcher can download its public pinned cache automatically. If you specifically want the copy in this dataset repository, materialize only the 100 active task directories before running:

from pathlib import Path

from datasets import load_dataset
from huggingface_hub import snapshot_download

task_ids = load_dataset("tencent/OSWorkerBench")["test"]["id"]
snapshot_download(
    repo_id="tencent/OSWorkerBench",
    repo_type="dataset",
    local_dir="osworker_cache",
    allow_patterns=[f"{task_id}/**" for task_id in task_ids],
)

# The mirrored cache content comes from this immutable source revision.
Path("osworker_cache/.HF_REVISION").write_text(
    "b6753bc357a756301f3429a95b38362da6035030\n"
)

The launcher will reuse this existing osworker_cache/. The qcow2 is intentionally not mirrored here; the launcher retrieves it from the pinned source linked under Runtime assets.

9. Results and scoring

Each launcher prints the final result directory. Under it, per-task artifacts follow this structure:

<result-dir>/pyautogui/screenshot/<model>/<domain>/<task-id>/
  result.txt
  ... logs, trajectory artifacts, screenshots, and optional video

result.txt contains the scalar evaluator score for that task. At the end of a run, the harness prints the number of completed tasks, aggregate score, and a per-domain breakdown. Missing result.txt files are treated as incomplete runs and are retried according to RETRY_MISSING_RESULTS and MAX_MISSING_RESULT_RETRIES.

For comparable published numbers, keep the released task manifest, task budget, environment, evaluator files, and model-serving settings fixed. Record the model revision, dataset/cache revision, config YAML, GPU/vLLM settings, and REPEAT_RUNS with the result.

Troubleshooting

• Mock connection failures: verify MOCK_APP_BASE_URL has no port/path and that ports 8100-8197 are reachable from inside the VM.
• Model not found from an existing endpoint: make the endpoint's --served-model-name match the config's MODEL_NAME.
• Cache revision mismatch: remove and re-download osworker_cache/. ALLOW_UNVERIFIED_CACHE=1 should only be used for a manually verified cache.
• Missing VM or low disk space: the qcow2 alone is 27.45 GB; confirm the download completed and leave additional space for model weights and videos.
• Partial run: inspect .missing_result_tasks.txt in the printed result directory. The launcher retries missing cases within that run; if cases are still missing after the configured retries, fix the infrastructure issue and start a new run.
• Proxy deployment: configure HTTP_PROXY, HTTPS_PROXY, NO_PROXY, OSWORLD_PROXY_HOST, and OSWORLD_PROXY_PORT as documented in the full benchmark README.

Configurations and splits

Configuration	Split	Rows	Unit
tasks (default)	test	100	One OSWorkerBench task
demonstrations	test	3,989	One captioned GUI action step

The 33 released self-demonstrations contain 212 subtasks and 3,989 steps. The 45 variant-task demonstrations described by the paper and project README are not present in the released osworker_bench/ tree and are therefore not included here.

tasks schema

The leading columns (id, domain, instruction, app_type, difficulty) are intended for browsing. config_json, evaluator_json, and task_json preserve the heterogeneous benchmark structures as lossless JSON strings. source_path points to the original task JSON and cache_path points to its same-named runtime-cache directory.

demonstrations schema

Each row identifies a task, subtask, and step and flattens the recorded observation, planner intent/thought/expectation, executor action, and post-action validation. step_json preserves the original step object and source_path points to the complete trajectory.

Repository layout

data/
  tasks/test-00000-of-00001.parquet
  demonstrations/test-00000-of-00001.parquet
raw/evaluation_examples/
  OSWorker/                         # full manifest and 100 task JSON files
  democua/                          # 33 task configs and raw trajectories
metadata/
  source_cache_manifest.json
  build_summary.json
<task-id>/                          # runtime setup/reward/cache files
legacy/                             # mirrored legacy cache files
images/osworld_image.tar

The README metadata explicitly maps load_dataset() to the two Parquet files, so the mixed runtime files are not interpreted as tabular data.

Runtime assets

The runtime cache is mirrored from SamuelGuo/OSworker_cache at immutable revision b6753bc357a756301f3429a95b38362da6035030. All files from that revision are included with their original paths except the large qcow2 VM image. metadata/source_cache_manifest.json records the source file list.

The omitted VM image is 27,445,690,368 bytes and can be downloaded directly from the pinned source revision:

• images/Ubuntu_openpyxl.qcow2
• SHA-256: ec20b56ed19d2fe2cca0f11d8fb3564cfd2926996a4a984ad12ace5af73acb5d

images/osworld_image.tar is mirrored in this repository. Running the benchmark also requires the harness and 98 mock applications from the UI-Mate GitHub repository. Of the 100 tasks, 88 use the mock applications and 12 are local-file/OSWorld-style tasks.

For the normative task-id, config, cache, and endpoint rules, use the OSWorker task specification.

Data provenance and privacy

Task prompts, executable evaluators, and released demonstrations come from the UI-Mate OSWorkerBench release. The benchmark uses synthetic enterprise records and fictional names/contact details; it is not intended to contain real personal data. Some inherited OSWorld-style tasks reference upstream Hugging Face assets, and those URLs are retained verbatim for reproducibility.

Runtime files are preserved from the pinned source-cache revision, including its legacy files and generation logs. Do not treat mock credentials or fixture values as production secrets.

Limitations

• This dataset provides benchmark definitions and assets, not a ready-to-run hosted environment. Docker/VM support and separately deployed mock apps are required for execution.
• Browser and desktop interactions may depend on UI versions, timing, network access, and the configured mock host.
• The default table serializes heterogeneous executable setup/evaluator objects as JSON strings; use json.loads or the raw files to reconstruct them.
• Only the 33 self-demonstrations present in the released repository are included.

License and attribution

The benchmark release is provided under Apache-2.0. See LICENSE, LICENSE.osworker, NOTICE.cua-gym, and TRADEMARKS.cua-gym.md for upstream attribution and trademark terms. Bundled runtime images and third-party software/assets remain subject to their respective upstream licenses.

Citation

@article{uimate2026,
  title   = {UI-Mate: Advancing Open-Weight Foundation GUI Agents with In-Context Demonstrations},
  author  = {Tencent HY Frontier Team},
  journal = {arXiv preprint arXiv:2608.15930},
  year    = {2026},
}