SOURCE-REVIEWED COMPARISON

Compare GUI-agent benchmark protocols

Match the task setting, available observations, action interface, and evaluator to the capability you need to measure.

61 profiles are available among 89 reviewed benchmarks in the catalog. Remaining entries are available in the full directory. Missing values mean not recorded.

Counts retain their units and subsets; figures are publisher-reported unless marked computed. Different resources can describe parts of the same project.

Showing 61 of 61 profiles.

Scroll the table sideways to see all columns.

Resource / settingObservations / actionsEvaluationScale with scope
AgentRewardBench
web

automatic evaluator agreement, task success, side effects, repetition
offline

Observe
web trajectories, screenshots, actions
Act / output
judge verdicts
Compare automatic judgments with expert answers on task success, side effects and repetitiveness.
  • 1,302 trajectories — paper-reported expert-reviewed set source
Scope and source notes

Counts refer to the paper study; current Hub package files are not converted into trajectory totals.

AndroidArena
android

multi-step Android tasks, cross-app workflows and instruction constraints
interactive

Observe
UI hierarchy text, screenshots, combined text/image observations
Act / output
app launch/stop, click/double-click/long-click, text input, swipe/drag and Android navigation, finish
The released evaluator compares trajectories with reference actions using longest-common-subsequence-based task reward and completion. Its reversed redundancy metric is the reference/predicted action-length ratio (with 1e-6 denominator smoothing), multiplied by the LLM success flag. LLM success judgments and instruction-constraint checks are separate metrics. Full reference-dependent evaluation coverage cannot be assumed because complete annotated action sequences are not released.Not recorded
Scope and source notes

README states that task instructions are released but annotated action sequences, apart from the calendar example, will come later. Environment setup targets Android API 33 with uiautomator2 and manual Google-account setup. Public task YAML and evaluator code exist, but benchmark execution and full reference coverage were not verified. No task total is derived from app YAML file counts. Code and data licenses remain unknown.

AndroidLab
android

Android task completion, subgoal completion, operation efficiency
interactive

Observe
UI XML, set-of-marks views
Act / output
Android operations through the agent framework
The evaluation pipeline produces success, subgoal success, reversed redundancy, and reasonable-operation metrics; result generation requires a configured judge model.
  • 138 tasks — benchmark task collection source
  • 9 applications — benchmark application set source
Scope and source notes

The benchmark uses predefined virtual-device images and apps chosen to work without network/login requirements. XML and SoM modes should be reported separately. These counts concern evaluation tasks, not the separately released Android Instruct training set.

AndroidWorld
android

mobile task completion
interactive

Observe
screenshots, accessibility information
Act / output
Android device interactions
Programmatic task-specific initialization, system-state success checks, and teardown.
  • 116 task definitions — parameterized AndroidWorld tasks source
  • 20 applications — documented AndroidWorld app set source
Scope and source notes

Random parameters produce many instances from the same task definitions. Preserve seeds and parameterization; 116 is not a count of all possible task instances.

AppSim-Bench
android

mobile task completion
interactive

Observe
mobile interfaces
Act / output
mobile GUI operations
Controlled backend data and outcome-based task verification.
  • 557 tasks — AppSim-Bench paper-described release source
  • 17 applications — published simulated app set source
Scope and source notes

Use the simulated apps and controlled backend state supplied by the benchmark. Desktop host instructions are not the platform being evaluated.

AppWorld
unspecified

interactive coding, cross-app tool use
interactive

Observe
API documentation, execution feedback
Act / output
Python code, application API calls
State-based unit tests check task outcomes and unintended changes.
  • 750 tasks — original AppWorld benchmark (2024 paper) source
  • 9 applications — original AppWorld environment (2024 paper) source
Scope and source notes

This is an adjacent API/coding benchmark, not a screenshot-only task suite. Preserve the named release; task counts here refer to the original paper.

B-MoCA
android

Android control across visual/device variation, generalization across environment snapshots
interactive

Observe
screenshot pixels, XML view hierarchy, goal instruction
Act / output
normalized touch/lift coordinate pairs for tap or swipe
Task success is detected using Appium; positive task reward terminates the episode. Environment variants change device/locale/wallpaper/DPI/dark mode and are loaded as snapshots. The numeric action interface is (touch_y, touch_x, lift_y, lift_x); wrapper/tanh transformations must be kept with the evaluated agent.
  • 131 task-definition files — asset/tasks/**/*.textproto in retained release/ver.3 tree; not a paper test-task total (computed) source
  • 35 environment configuration rows — environments_train.csv, retained release/ver.3 snapshot (computed) source
  • 10 environment configuration rows — environments_test.csv, retained release/ver.3 snapshot (computed) source
Scope and source notes

Current source inventory differs in grain from published experiment subsets: do not multiply 131 definitions by 35/10 configuration rows or label the product as evaluated tasks. Setup requires Android API 29, Appium, external app versions and generated AVD snapshots. No apps/snapshots were downloaded or run. Code Apache-2.0 does not establish data or app rights.

BrowserGym
web

shared browser-agent evaluation interface, benchmark adapters with separate task definitions
mixed

Observe
browser screenshot, DOM snapshot, accessibility tree, tab/URL state, previous action and its error, chat messages and task goal
Act / output
element-ID actions, coordinate mouse and keyboard actions, tab/navigation/scroll operations, Python/Playwright action mode
Gymnasium reset/step interface delegates reward, completion, messages and task info to each adapter’s validate() method. There is no universal BrowserGym success metric or shared task total; retain benchmark/adapter version and action subset for comparisons.Not recorded
Scope and source notes

A framework with interactive browser adapters and a static WebLINX evaluation integration, so the profile setting is mixed. README-listed integrations are not added as disjoint tasks or datasets. Core requires Playwright/Chromium; individual benchmarks have their own setup, credentials, licenses and validation rules. Apache-2.0 covers repository code only. No browser tasks or third-party project code were executed.

ColorBench
android

long-horizon mobile task completion, multi-path graph interaction
interactive

Observe
mobile screenshots represented as graph states
Act / output
mobile GUI operations along graph transitions
The publisher reports success rate, completion rate and atomic-capability diagnostics using graph-based evaluation.
  • 175 tasks — reported ColorBench benchmark source
  • 101 cross-app tasks — reported ColorBench benchmark source
  • 74 single-app tasks — reported ColorBench benchmark source
  • 21 mobile applications — reported ColorBench benchmark source
Scope and source notes

The interaction environment replays graph states rather than running real user accounts. The 101 and 74 subsets partition the reported 175 tasks; do not add the three counts.

CRAB
desktop, android

cross-environment tasks
interactive

Observe
Not recorded
Act / output
Python-defined environment actions
Graph-based evaluators measure progress through task requirements.
  • 120 tasks — CRAB Benchmark-v0 (paper) source
Scope and source notes

CRAB is also an extensible framework. The 120-task count belongs to Benchmark-v0, not every environment that can be created with the framework.

CUAVerifierBench
web

verifier-human agreement, process quality
offline

Observe
screenshots, action logs, final answers
Act / output
success verdict, process score
Agreement metrics including Cohen’s kappa, accuracy and F1 against human annotations; review stages must be kept distinct.
  • 106 trajectories — fara7b_om2w_browserbase split source
  • 154 trajectories — internal split source
  • 215 annotation rows — fara7b_om2w_browserbase split source
  • 154 annotation rows — internal split source
Scope and source notes

Trajectory rows and reviewer rows have different grains. Internal task labels do not make the released Parquet files private. No payload data was downloaded.

FedMABench
android

mobile-agent federated training, data heterogeneity
offline

Observe
mobile-agent examples with externally sourced screenshots
Act / output
model predictions on mobile-agent examples
The provided evaluation workflow performs model inference over selected partitions and invokes test_swift_fed.py for accuracy scoring.
  • 6 dataset families — released FedMABench partition families source
  • 3 heterogeneity types — publisher benchmark overview source
  • 8 federated learning algorithms — publisher benchmark overview source
Scope and source notes

The dataset-family count does not count tasks, apps, screenshots or client instances. Code and data licenses are unknown; external image sources are required.

GUIHalluBench
cross-platform

GUI page-element detection, element-description consistency
offline

Observe
page screenshot
Act / output
list of UI element boxes [x1,y1,x2,y2] and text descriptions
Metrics use greedy one-to-one matching in descending IoU order, then micro precision/recall/F1 and lowercased difflib.SequenceMatcher description similarity on matched pairs. Actual metrics.py accepts IoU >= 0.5 at its default threshold; README prose says > 0.5. Predictions align to annotations by image_path; callers must supply complete prediction coverage because missing predictions are not independently enumerated by evaluate_dataset.
  • 1,000 page-annotation entries — English annotation subset reported by README source
  • 1,000 page-annotation entries — Chinese annotation subset reported by README source
Scope and source notes

Each annotation entry represents a page, not one UI element. README’s illustrative num_samples=4796 output is not adopted as a corpus count. Public tree contains both annotation JSON files and an images.tar.gz Git-LFS pointer; payload availability/integrity was not tested by downloading images. LEGAL.md only governs comment-language precedence, not a code/data license grant; both slots remain unknown. No benchmark run was performed.

iOSWorld
ios

personalized phone tasks, cross-app workflows
interactive

Observe
screenshots, accessibility XML (optional)
Act / output
touch actions, MCP tools (optional)
Rubric satisfaction per task; full-task pass requires every criterion to be satisfied.
  • 133 tasks — tasks.json benchmark source
  • 26 applications — bundled SwiftUI apps source
Scope and source notes

Vision-only, vision-plus-XML, and MCP modes expose different information and tools. The documented default evaluator is model-based; compare the same mode and judge.

LlamaTouch
android

mobile task completion, essential-state evaluation
interactive

Observe
screenshots, view hierarchies, Android activity names
Act / output
device actions through AgentEnv
Checks whether the recorded execution visits all annotated essential states rather than requiring an identical action sequence.
  • 495 tasks — complete task collection source
  • 102 tasks — AITW-derived subset source
  • 393 tasks — self-constructed subset source
  • 46 Android applications — self-constructed subset source
Scope and source notes

Application coverage refers to the self-constructed subset. Task execution and essential-state annotation are separate components; counts are publisher-reported, not a fresh task-file recount.

MacAgentBench
desktop, macos

macOS task completion, cross-application workflows
interactive

Observe
Not recorded
Act / output
GUI interactions, command-line operations
Deterministic rule-based evaluators with intermediate checkpoints.
  • 676 tasks — documented MacAgentBench suite source
  • 25 applications — documented application coverage source
Scope and source notes

The benchmark evaluates multiple agent frameworks and GUI/CLI workflows. Framework skills and interfaces affect the task setting; the inspected README does not define one universal observation representation.

Mind2Web
web

web action prediction, generalization to unseen sites and domains
offline

Observe
task instructions, HTML, recorded action history
Act / output
CLICK, TYPE, SELECT
Offline candidate and action evaluation against recorded demonstrations; the repository distinguishes macro from micro averaging.
  • 1,009 task instances — train split source
  • 252 task instances — cross-task test split source
  • 177 task instances — cross-website test split source
  • 912 task instances — cross-domain test split source
Scope and source notes

These are reported split inventories, not online task-success measurements. Original Mind2Web, Multimodal-Mind2Web, and Online-Mind2Web have different inputs/protocols. The authors require macro-average metrics for comparison with the paper; test archives remain upstream.

MiniWoB++
web

small web interaction tasks
interactive

Observe
task instructions, screenshots, visible DOM-element attributes
Act / output
configurable coordinate actions, element-reference actions, keyboard input
Not recorded
  • > 100 web environments — README collection size source
Scope and source notes

The README gives a lower bound, not an exact active-environment inventory. Action presets expose different capabilities, so comparisons must identify the preset. Environment-specific reward details are not normalized here. The repository is in maintenance mode.

MMBench-GUI
cross-platform

screen understanding, grounding, task automation, task collaboration
mixed

Observe
screenshots
Act / output
Not recorded
Level-specific evaluation; Efficiency–Quality Area (EQA) combines navigation quality and efficiency.
  • > 8,000 tasks — reported multi-level benchmark source
Scope and source notes

The README documents four levels, but its release notes and TODOs distinguish released L1/L2 evaluation from pending L3/L4 integration. Do not treat every level as the same evaluator or a complete implemented interface.

MobBench task definitions
android

mobile task completion
interactive

Observe
Android device interface
Act / output
mobile GUI actions through a separately configured agent
The publisher reports a fifty-task real-device evaluation; the inspected release does not establish an automatic correctness judge.
  • 50 tasks — MobBench tasks used in the paper source
Scope and source notes

Task definitions are distinct from device images, agent execution and automated scoring.

Mobile-Bench-v2 released data
android

offline multi-path evaluation, noisy interfaces, ambiguous instructions
offline

Observe
mobile screenshots, XML UI state, instructions
Act / output
mobile UI actions, clarification responses
Paper defines multi-path and noise/ambiguity evaluations; the public card identifies which files are full common-task sets and which are samples.Not recorded
Scope and source notes

Release completeness differs by split. No full-benchmark sample total is inferred from the archive manifest.

Mobile-Eval-E task definitions
android

long-horizon multi-app Android task execution
interactive

Observe
task instructions, app/scenario metadata
Act / output
Not recorded
The published task schema contains rubrics and human_reference_operations. No automated scoring protocol or single numeric agent metric is established by the inspected card; execution uses separately configured Android tooling.
  • 25 task-definition records — Hub test split at revision b8eca829 source
Scope and source notes

Features are task_id, instruction, type, apps, scenario, rubrics and human-reference operation strings. A task record is not an action count or recorded screenshot trajectory. Public Parquet inventory was checked but no sample rows were downloaded; companion README limits the tested agent platform to Android.

MobileGUI-VBench
unspecified

mobile task completion, clarification behavior, cross-app tasks
interactive

Observe
mobile app interfaces
Act / output
mobile interface operations, clarification requests
Published task definitions include preconditions and clarification requirements; the metadata review does not independently validate the reported agent scores.
  • 150 tasks — MobileGUI-VBench release source
  • 40 mobile apps — MobileGUI-VBench release source
Scope and source notes

The card describes 140 single-app and 10 cross-app tasks. Task and app counts are different units.

MobileGym
web

mobile GUI task completion in simulation, state verification and parallel training
interactive

Observe
simulated mobile screenshots, structured simulator state for judges
Act / output
tap, type, swipe, back, home, drag, complete
Deterministic task judges inspect state changes; reported metrics distinguish success, progress, false completion and unexpected side effects.
  • 416 task templates — publisher benchmark overview source
  • 28 simulated apps — publisher benchmark overview source
  • 160 task identifiers — bench_env/splits/train.txt (computed) source
  • 256 task identifiers — bench_env/splits/test.txt (computed) source
Scope and source notes

The split-ID inventory is not a count of sampled trajectories, live Android apps or real user accounts. Extra runtime/data dependencies and third-party content terms remain distinct.

MobileGym++ / MobileGym++ Bench
web

task completion, cross-application workflows, GUI and app-native tool comparison
interactive

Observe
screenshots
Act / output
GUI gestures, foreground-app tool calls in hybrid mode
Programmatic checkers inspect changes in application state; both modes share task definitions and initial states.
  • 215 task definitions — official.json (computed) source
  • 63 simulated clients — complete simulator installation source
  • 35 simulated clients — new clients in this release source
Scope and source notes

The task count was checked against unique task_id values in the published manifest. The 35 new clients are a subset of 63 total clients. This simulator runs in a browser; Android-emulator apps are a separate part of OpenMobile-2.

MobileSafetyBench
android

mobile task helpfulness, harm prevention during Android interaction
interactive

Observe
screenshot pixels, parsed UI hierarchy text, task instruction and interaction history
Act / output
tap/long-tap/swipe, navigation buttons and text editing, refuse, ask-consent and complete, task-specific shortcut actions
Appium-backed task evaluators track goal achievement and harm prevention as separate booleans, plus risk-detection step and completion progress. The base evaluator defaults to max_step=15; task-specific overrides must be retained. Results are not a single generic success-rate metric.Not recorded
Scope and source notes

Inspected release/ver.3 branch exposes task definitions, Android environment and per-task evaluators. It requires Android API 34, Appium/ADB and documented third-party app versions; those APKs/accounts were not acquired. The action parser includes semantic shortcuts in addition to screen gestures, so this is not a strictly coordinate-only action setting. No corpus task total is inferred from evaluator-module or file counts. Apache-2.0 applies to repository code, not automatically app/data assets.

MobileWorld (Tongyi-MAI)
android

Android task completion, agent-user interaction, hybrid GUI and MCP use
interactive

Observe
Android application interface, user-agent interaction when enabled
Act / output
Android GUI operations, MCP calls when enabled, agent-user interaction when enabled
The publisher documents text-answer matching, backend database verification, local-storage inspection and application callbacks.
  • 201 tasks — README benchmark overview source
  • 20 mobile applications — README benchmark overview source
Scope and source notes

Publisher-reported inventory. GUI-only, agent-user and MCP-augmented configurations have different dependencies and task eligibility; preserve enabled modes and step budget with results.

OmniAct
desktop, web

offline desktop/web action-script generation
offline

Observe
screenshot, natural-language task
Act / output
PyAutoGUI script: pointer movement/click/drag, key presses, hotkeys, and text entry
The bundled evaluator reports weighted sequence match and action match, comparing action types and applying coordinate, key, and writing penalties. Target element-box metadata is evaluation-only. The retained scorer has a click-penalty defect: predicted coordinates are read from gold_line, so score reproduction requires explicit scorer-version review.
  • 6,788 task examples — train split, HF revision 5e4bcb26 source
  • 2,020 task examples — test split, HF revision 5e4bcb26 source
  • 991 task examples — val split, HF revision 5e4bcb26 source
Scope and source notes

This released split table totals 9,799 examples; it is not silently substituted for any paper-level collection size. Public files include train/test/val JSON indexes, task/image archives, and eval.py. Evaluation is offline script comparison, not execution success on a live desktop. MIT is the Hub data declaration; original app/content rights are not resolved by it.

Online Mind2Web
web

live-web task completion
interactive

Observe
Not recorded
Act / output
web interactions
Human evaluation and WebJudge-based evaluation are documented as distinct assessment paths.
  • 300 tasks — documented Online-Mind2Web suite source
  • 136 websites — documented site coverage source
Scope and source notes

Tasks are actively replaced when websites or requirements become invalid. Record the task revision and submission schema; a constant headline task count does not imply an unchanged test set.

OpenApps
web

UI-agent reliability under environment variation, state-based browser task evaluation
interactive

Observe
screenshots, accessibility trees, set-of-marks and coordinates (configurable)
Act / output
click, type, scroll, configured BrowserGym/AgentLab actions
Tasks define check_if_task_is_complete(initial_state,current_state); app-specific reward logic evaluates underlying state, with custom checks for code-editor file contents. Observation/history flags are configurable. No universal single fixed task total or published-run reproduction is implied.Not recorded
Scope and source notes

Preserve the code/tag, app state, theme/layout/content choices, goal variant and action/observation configuration. Current main refactors the paper-era appearance surface, and the v1.0-paper tag includes post-publication fixes that may move rewards. The environments run as browser apps; phone/tablet viewports are not native Android/iOS environments.

OS-Critic Bench
cross-platform, desktop, web

GUI critic prediction
offline

Observe
benchmark JSONL, UI screenshots
Act / output
critic-model responses
The official repository runs model inference and computes accuracy with cal_acc.py.
  • 3 platform JSONL splits — mobile/desktop/web configurations in the Hub card (computed) source
Scope and source notes

No sample count is inferred from the n<1K Hub size band. Evaluation code availability does not establish the release of OS-Oracle training data or weights.

OS-Harm
desktop

deliberate misuse, prompt-injection safety, unintended harmful behavior during normal tasks
interactive

Observe
screenshot, accessibility tree, screenshot plus accessibility tree, set-of-marks
Act / output
OSWorld/PyAutoGUI desktop interaction
Automated LLM judge scores both task accuracy and safety from saved execution traces. Keep judge model/prompt version and harm category with a result; the scripts separately compute predicted metrics. This is an interactive desktop safety benchmark, not a single offline grounding score.
  • 150 tasks as reported by the paper/README — reported benchmark total; not a recount of unique released task IDs source
  • 50 task IDs — released misuse task-ID list; before injection/goal expansion (computed) source
  • 10 task IDs — released injection task-ID list; before injection/goal expansion (computed) source
  • 50 task IDs — released misbehavior task-ID list; before injection/goal expansion (computed) source
Scope and source notes

README/paper reports 150 tasks, whereas retained misuse/injection/misbehavior lists contain 50/10/50 IDs. run.py expands injection vectors/goals, so the released ID inventory is not a direct recount of paper settings; the complete expanded total was not reconstructed. Judge agreement F1 values in the README measure agreement with human labels, not agent success. Experiments use OSWorld desktop apps, with VMware documented as tested and screenshot/a11y/SOM observation choices. Code Apache-2.0 does not establish VM/app/data rights. Publisher asks that the benchmark not be used directly as agent training data.

OS-Map
desktop, linux

breadth of desktop task coverage, depth of desktop task execution
interactive

Observe
desktop observations from an Ubuntu virtual machine
Act / output
actions executed by the OSWorld-derived DesktopEnv
Task configurations provide evaluators for application/system state, using an OSWorld-derived runtime.
  • 416 category/task references — evaluation_examples/all.json (computed) source
Scope and source notes

416 category/task pairs are unique, but only 412 bare ID strings are unique across categories. This is a manifest-reference count, not a claim of 416 semantically distinct tasks. Main runtime documentation specifies Ubuntu; the subdirectory README retains older Windows-only wording.

OSWorld
desktop, linux, windows, macos

task completion, cross-application workflows
interactive

Observe
screenshots
Act / output
mouse and keyboard via PyAutoGUI
Task-specific execution-based evaluators inspect application or system state.
  • 369 task definitions — test_all.json (computed) source
  • 361 task definitions — test_nogdrive.json (computed) source
Scope and source notes

Counts were computed from unique task identifiers in the two inspected manifests. The subsets differ; record the manifest, repository revision, agent interface, and step budget with a score.

OSWorld-G
desktop

desktop GUI grounding, infeasible-target refusal
offline

Observe
screenshot, instruction
Act / output
click point or box center, refusal represented by negative coordinates in the evaluator
The inspected Jedi runner maps predictions from resized-image coordinates back to the original image, then checks the predicted center against rectangle/polygon targets or the refusal rule. It reports overall and classification-group accuracy. This is offline grounding, not OSWorld task-execution success.Not recorded
Scope and source notes

The repository retains original OSWorld-G.json and refined OSWorld-G_refined.json instructions; treat them as alternative benchmark versions, not additional disjoint tasks. Refined instructions reduce requirements beyond grounding. The same repository also contains Jedi training/rendering material, which is excluded from benchmark counts. The standalone generic eval.py entry point is a stub; the named model runner supplies image_size to its geometry helper. No task count or successful execution is inferred from repository file totals. Apache-2.0 is recorded for code only.

OSWorld-Human
desktop

action efficiency relative to humans
offline

Observe
OSWorld result trajectories, human reference actions
Act / output
efficiency scores
The scorer consumes OSWorld results and a specified maximum step budget; the README distinguishes single-action and grouped-action WES+ and WES-.Not recorded
Scope and source notes

Reference solutions are published for evaluation and expressly discouraged for training. No task count is inferred from file count.

Precision CUA Bench
cross-platform

pixel-precise editor cursor placement, multi-turn visual self-correction
offline

Observe
code-editor screenshot, cursor-location instruction, red-cross feedback marking previous incorrect prediction
Act / output
pixel (x,y) cursor coordinate
The inspected evaluator scales target boxes from a 1000×1000 reference grid into image pixels and tests pixel predictions, allowing ±10 pixels around the center along any target dimension narrower than 1 pixel after scaling. It reports cumulative hit accuracy by turn (earlier hits remain correct), miss distances, any-turn hit rate, and a correction rate whose denominator is all successfully processed samples. The default budget is five turns; retain prompt/feedback variant, turn budget, and processed/skipped coverage.Not recorded
Scope and source notes

The release has four editor/theme JSONL partitions (Cursor/VS Code × dark/light) and screenshot files. Partitions are not train/test splits or independent task totals. README’s initial field table calls bbox pixel coordinates, but the evaluation-format section and actual ratio_h/ratio_w=dimension/1000 code use normalized target boxes; profile follows the inspected evaluator and retains the inconsistency. Source/images were not executed or downloaded as a dataset. MIT is recorded for repository code only.

SafeArena
web

web-agent safety, task completion
interactive

Observe
Not recorded
Act / output
web interactions
Task outcomes and the Agent Risk Assessment categories evaluate agent behavior on benign and harmful requests.
  • 250 tasks — safe split source
  • 250 tasks — harmful split source
Scope and source notes

Use SafeArena-specific containers rather than ordinary WebArena instances. The documented task splits require access approval; the profile does not imply unrestricted dataset access.

ScienceBoard
desktop

scientific-software desktop workflows, GUI and code-assisted scientific tasks
interactive

Observe
desktop screenshots, accessibility-tree observations, set-of-marks with accessibility tree
Act / output
PyAutoGUI desktop actions, code/tool commands and answer/stop actions according to configured agent mode
Application-specific verifiers inspect state, files, database values, equations, compilation or answer/stop conditions. The official audit records 242 verifier entries across its VM task suite. This profile covers the released VM task definitions; Docker smoke results and Raw/Dual alternatives are separate populations.
  • 169 VM task definitions — tasks/VM/**/*.json at tree 21b5eb0f; excludes tasks/Raw and tasks/Dual (computed) source
  • 6 application families — VM suite: Celestia, ChimeraX, GrassGIS, KAlgebra, Lean, TeXstudio source
Scope and source notes

Manifest count 169 matches the official verifier audit. Other Raw/Dual definitions can represent alternative execution modes of the same problems and are not added. Official Docker migration documents a 20-task acceptance subset, not a full-suite performance result; legacy VMware remains. External service sign-in/rate limits, amd64 binaries and ChimeraX redistribution terms limit portability. Only code MIT is established; VM, scientific data and bundled apps need their own terms.

ScreenSpot
cross-platform

single-step GUI element grounding
offline

Observe
screenshot, English instruction
Act / output
predicted click point; a predicted box is reduced to its center
The SeeClick evaluator scores whether the predicted point falls inside the target box, with platform and text/icon breakdowns. The Hub packaging uses xyxy boxes, whereas the original evaluator reads xywh and converts it; adapt the loader to the chosen release.
  • 1,272 instruction–target examples — Hub test split at 0be08781; not unique screenshots source
Scope and source notes

Offline, zero-shot evaluation across mobile, desktop, and web. The card explicitly excludes training use in its intended-use description. Public API reports ungated Parquet files and canonical Hub id bevaya/ScreenSpot; the catalog identity is preserved. Apache-2.0 is the Hub data declaration. No runtime or underlying screenshot rights audit was performed.

ScreenSpot Pro
desktop, windows, macos, linux

GUI grounding
offline

Observe
high-resolution screenshots, target instructions
Act / output
predicted target coordinates
For positive targets, the predicted point must fall inside the annotated bounding box.
  • 1,581 target annotations — sum of icon/text counts in the published card table (computed) source
Scope and source notes

Language, instruction style, and positive/negative target configuration are explicit evaluator options. This profile describes target localization, not end-to-end workflow completion. The target count is computed from the card table, not from expanded language/style evaluation instances.

ScreenSpot v2
cross-platform

single-step GUI grounding on the ScreenSpot-v2 release
offline

Observe
screenshot, instruction
Act / output
click coordinates
The inspected Jedi evaluation adapter reads the v2 mobile/desktop/web annotation files, scores a point against the target box, and reports overall, platform, and text/icon accuracy. This is a named compatible evaluator implementation; the OS-Atlas dataset card itself supplies no evaluator specification.Not recorded
Scope and source notes

The public Hub revision 5efbb1f1 contains three platform JSON annotation files and an image ZIP; its card only declares Apache-2.0. No sample total or equivalence to the original ScreenSpot test count is asserted. Keep v2 separate from v1 and retain evaluator/version and coordinate conversion when comparing results. Files were listed, not downloaded as data.

ScreenSpot-v2 instruction variants
cross-platform

instruction-form robustness, negative grounding requests
offline

Observe
screenshots, instructions
Act / output
target localization, identification of impossible requests
Publisher supplies original, action, description and negative instruction types; no common end-to-end success metric is asserted.
  • 4 instruction types — instruction-variant design source
Scope and source notes

Reuses ScreenSpot-v2 imagery. Image-file count is not treated as a count of independent screenshots or tasks.

SPA-Bench
android

mobile task completion, resource use, cross-app workflows
interactive

Observe
screenshot trajectories
Act / output
agent-specific Android actions
A multimodal evaluator and annotated key-component matching assess completion; the framework also reports resource-use metrics.
  • 340 tasks — complete README task collection source
  • 300 tasks — single-app subset source
  • 40 tasks — cross-app subset source
  • 66 applications — README total including third-party, Google, and system apps source
Scope and source notes

The two task subsets partition the 340 tasks. The integrated agent and evaluator modes must accompany results. The preconfigured emulator snapshot is still marked coming soon in the inspected documentation.

Spider2-V
web, desktop

data-science workflows, multi-application task completion
interactive

Observe
screenshots, accessibility trees, set-of-marks views
Act / output
PyAutoGUI mouse and keyboard actions
Task-specific evaluation functions are invoked after agent execution.
  • 494 task definitions — evaluation_examples/test_all.json (computed) source
  • 20 applications — README task-suite coverage source
Scope and source notes

Counted unique task IDs in the full manifest. Verbose versus abstract instructions and account versus non-account tasks form different subsets. The Ubuntu VM and external-account requirements are part of the protocol; no accounts or environments were provisioned.

TheAgentCompany
web, desktop

professional workflows, multi-tool tasks
interactive

Observe
Not recorded
Act / output
web browsing, code execution, coworker communication
Task-specific evaluator scripts run within the prepared workplace environment.
  • 175 task images — workspace images documented by the README source
Scope and source notes

Each task is packaged as a Docker image. Record task-image and server versions; the environment includes simulated coworkers and external application state.

VisualWebArena
web

multimodal web task completion
interactive

Observe
screenshots with set-of-mark annotations, caption-augmented accessibility tree
Act / output
browser element actions
Execution-based completion checks for visually grounded web tasks.
  • 910 tasks — full VWA suite source
  • 233 human trajectories — one task from each template type source
Scope and source notes

The 233 demonstration trajectories are not the full 910-task evaluation set. Observation modes and captioning components differ across baseline agents.

Web Context Bench (Python)
web

Browser-representation token use, Factual READ accuracy, ACT target-element selection
offline

Observe
Top-document HTML, Markdown converted from HTML, Playwright accessibility snapshot, Browser Use indexed DOM, Stagehand hybrid snapshot, Viewport screenshot
Act / output
READ text answer, ACT selector, text/label, accessible role/name, DOM index, Stagehand reference or screenshot point, according to the representation
READ uses normalized exact match against an answer or allowed alias. ACT resolves predicted identifiers to ground-truth elements, or checks screenshot points inside the target box. Representation-token accounting subtracts fixed-prompt tokens; screenshots use billed input usage minus the fixed prompt. These are answer/target correctness and token metrics, not completed-task success.Not recorded
Scope and source notes

Fixed local-page observations; the reported run uses claude-sonnet-5 and a shared prompt, without scrolling or an agent loop. Browser Use disables its viewport cutoff and sends untruncated text; Stagehand uses a separate matched browser load. Short-string representability labels are approximate. Offline does not mean API-free. Third-party snapshot redistribution remains unresolved; results were not reproduced.

WebArena
web

web task completion
interactive

Observe
HTML or accessibility tree
Act / output
browser element actions
Functional correctness of completed web tasks.
  • 812 task examples — canonical WebArena evaluation suite source
Scope and source notes

The canonical repository documents self-hosted websites and environment resets. Its README recommends BrowserGym/AgentLab for newer infrastructure; harness changes must be recorded.

WebClick
web

instruction-conditioned web localization
offline

Observe
web screenshots, instructions
Act / output
click target or bounding box
Assess localization against annotated targets; agentbrowse, humanbrowse and calendars are distinct source buckets.
  • 1,639 examples — test split source
Scope and source notes

The card reports more than 100 websites but does not provide a precise website total. Grounding accuracy does not establish task completion.

WebLINX
web

conversational web navigation, next-action prediction
offline

Observe
dialogue history, HTML, screenshots, action history
Act / output
predicted browser actions
Offline evaluation compares action predictions against recorded human demonstrations.
  • ≈ 100,000 interactions — original paper benchmark source
  • ≈ 2,300 expert demonstrations — original paper benchmark source
  • > 150 websites — original paper benchmark source
Scope and source notes

The figures are rounded descriptions from the original paper. WebLINX 1.1 / BrowserGym removes some demonstrations and changes evaluated steps, including tab actions; do not mix those results or counts with the original release. This profile does not treat replayed demonstration steps as live task completion.

WebRewardBench
web

web process-reward evaluation
offline

Observe
page screenshots, text observations, action history, task checklists
Act / output
candidate-decision preference
Compare reward-model preferences with the provided chosen/rejected decision labels; no independent score was reproduced.
  • 776 rows — Hub test split source
Scope and source notes

The current Hub row count and project case-count claim use unresolved counting units. Candidate lists mean a row must not be assumed to equal one task or one pair.

WebShop
web

instruction-conditioned product selection, web navigation
interactive

Observe
HTML pages, simplified text views
Act / output
search queries, click actions, product option selection
Not recorded
  • 12,087 instructions — crowd-sourced instruction collection source
  • ≈ 1,180,000 products — full product inventory source
Scope and source notes

This is a simulated shop. The default preview loads 1,000 products, while the full inventory is much larger; report the loaded subset and observation mode. Instructions and products are different populations. Detailed reward semantics are not normalized in this profile.

WebTailBench
web

live web task completion, unsafe-request refusal
interactive

Observe
web pages
Act / output
browser interaction
Task-specific precomputed rubrics; refusal tasks are a separate evaluation population.
  • 609 task identities — main V1/V2 suite (shared identities) source
  • 111 tasks — refusal suite source
Scope and source notes

V2 refreshes task strings and rubrics while preserving V1 task IDs. Counts are task definitions, not independently verified runnable website states.

WebTestBench
web

web functionality testing, latent permission and business constraints
interactive

Observe
web application interface, development instruction
Act / output
browser interaction, test checklist generation, defect reports
The supplied WebTester pipeline separates checklist generation from interactive defect detection and provides a scoring workflow.
  • 7 application categories — publisher benchmark overview source
  • 100 web-application archives — Hub file manifest (computed) source
Scope and source notes

The 100 archive files are not counted as 100 independent test tasks or defects. Backend/tool versions and deployment settings affect reproducibility.

WebVoyager
web

live-web task completion
interactive

Observe
webpage screenshots, textual task instructions
Act / output
Selenium-backed browser interactions
The repository supplies an automated multimodal-model evaluation protocol.
  • 643 task queries — WebVoyager task collection source
  • 15 websites — WebVoyager task collection source
  • 90 tasks — separate GAIA validation-derived web subset source
Scope and source notes

The GAIA-derived subset is separate from the 643 WebVoyager queries. Live sites and time-sensitive travel tasks can change; record the task snapshot and evaluation date.

Windows Agent Arena
windows, desktop

Windows task completion, desktop workflows
interactive

Observe
screenshots, accessibility information, screen-element detections
Act / output
agent-defined Windows interactions
Task configuration selects an evaluator and expected application or system outcome; evaluators return a reward for the resulting state.
  • 154 task definitions — evaluation_examples_windows/test_all.json (computed) source
Scope and source notes

Counted unique identifiers in the inspected manifest. Normal and hard modes differ in how much task setup the agent must perform. Record the difficulty and observation/backend configuration with each result; no VM was launched.

WindowsAgentArena-V2
desktop, windows

Windows desktop task execution, revised task evaluators
interactive

Observe
screenshot, accessibility tree, screenshot plus accessibility tree, set-of-marks
Act / output
PyAutoGUI
Runner exposes four observation choices and uses PyAutoGUI. count.py sums the last score in each results.json and divides by the number of traj.jsonl files, multiplying by 100; it separately reports result/trajectory/error-file coverage. This denominator is not automatically the full benchmark size.
  • 141 tasks — full WindowsAgentArena-V2 suite reported by README source
  • 11 Windows applications — full suite coverage reported by README source
  • 20 task IDs — shipped test_custom.json selection (computed) source
Scope and source notes

README sample config uses max_steps=30. The shipped selected-task index has 20 IDs, not 141; preserve the selected task list, trial ID, score coverage and VM snapshot when comparing runs. Docker/Windows-11 setup is required. No VM or benchmark was executed.

WindowsWorld
desktop, windows

multi-application Windows workflows, intermediate-state and final-goal completion
interactive

Observe
screenshot, accessibility tree, screenshot plus accessibility tree, set-of-marks
Act / output
PyAutoGUI, UiPath Computer_13 action interface
Publisher distinguishes S_int (intermediate checkpoint score on L1–L3) and S_final (final completion on L1–L4). Documented step budgets are 15/25/40/20 for L1/L2/L3/L4. Preserve level, observation mode, agent interface and checkpoint/final metric when reporting a run.
  • 181 tasks — WindowsWorld benchmark described in the retained README source
  • 17 desktop applications — WindowsWorld coverage described in the retained README source
Scope and source notes

Interactive VMware/Windows environment. The public repository includes benchmark.json, task/evaluator code and monitoring support; the README refers VM import to Installation Guide.md, whose distribution links and payloads were not inspected for this profile. Checkpoint counts and application counts are not extra tasks. Apache-2.0 is recorded for repository code; Windows, apps and VM artifacts retain separate terms.

WONDERBREAD
web

workflow documentation, workflow quality assessment, workflow knowledge transfer
offline

Observe
screen recordings, action traces, screenshots, written standard operating procedures
Act / output
generate procedures, segment demonstrations, answer workflow questions, validate and rank procedures
Task-specific scripts evaluate six workflow-understanding task types; model outputs are not treated as successful interactive execution.
  • 6 task types — WONDERBREAD BPM benchmark source
  • 2,928 human demonstrations — full dataset release 14094162 source
  • 598 web navigation workflows — full dataset release 14094162 source
  • 724 human demonstrations — gold subset used for the original paper evaluations source
Scope and source notes

Counts are publisher-reported. The gold subset covers 162 workflows and differs from the full collection; scores require the exact task and subset.

WorkArena
web

enterprise web workflows, compositional tasks
interactive

Observe
multimodal browser observations
Act / output
BrowserGym browser actions
Task-specific checks on ServiceNow workflows; levels and task configurations define different evaluations.
  • 33 task definitions — WorkArena-L1 atomic tasks source
  • 19,912 task instances — WorkArena-L1 documented instances source
  • 682 task definitions — WorkArena++ compositional tasks source
Scope and source notes

Definitions and instantiated tasks are different units. ServiceNow instance access is gated. WorkArena-L1 and WorkArena++ should be reported separately.

Use each resource page for source timestamps, content fingerprints, and separate code, data, and weight licenses.

Download these profiles as JSON · Complete catalog and SQLite · Compare datasets