The dataset viewer should be available soon. Please retry later.
GoldiBench run logs
All records of the experiments in the GoldiBench paper: every episode, every model output (program-channel programs and rationales, GUI replies and executed actions), scores, renders and screenshots, and the cost of the closed models. Built on 2026-11-20 from the original research storage, to answer questions about any number of the paper later.
- Benchmark (tasks): https://huggingface.co/datasets/VanWang/GoldiBench
- Code (harness, scorers, paper scripts): https://github.com/uservan/GoldiBench
- Project page: https://uservan.github.io/GoldiBench
1. What is included, and what is not
Included: only the experiments of the paper.
| part | where | paper |
|---|---|---|
| program channel, main results, 5 seeds (open models) / 1 run (closed) | program/<app>/<model>/main/seed0..4/ |
Tab. main (program), CIs, threshold sweep, scaling figures |
| program channel, interventions (Sec. 5) | program/<app>/<model>/<condition>/seed0/ |
Sec. 5, Fig. 1 teaser, fig. rounds |
| GUI channel, main results, 3 seeds (open) / 1 run (closed), 100 steps | gui/<app>/<model>/main/seed0..2/ |
Tab. main (GUI), scaling figures, Sec. 4.3 |
| validation experiments (human pairs, VLM judges) | supporting/validation_v5/ |
Sec. 4 |
| motivation experiments (judge stress test e3 / e3x) | supporting/motivation_e3*/, supporting/motivation_repo/ |
Sec. 2 |
| computed paper numbers (main tables, CIs, Sec. 4.3 / 5 numbers, score summaries) | supporting/paper_numbers/ |
all tables |
| closed-model costs (every API call of the project) | cost/ |
cost statements |
Not included: smoke tests, pilots, abandoned or superseded runs, runs that were redone after a harness fix, backups, trash and quarantine folders, model weights. (They exist only in the raw research snapshot, https://huggingface.co/datasets/VanWang/ves-raw-snapshot-20261120, as non-image files.)
2. Layout
README.md this file
runs.csv one row per published unit (= one run of one app, or one supporting folder)
episodes_paper.parquet every episode of the paper in one table
cost/summary.csv closed models: calls, tokens, USD per model (+ totals)
cost/by_day.csv the same per day
cost/calls.parquet every API call: time, model, input / output tokens, USD, stop reason, error
program/<app>/<model>/<condition>/seed<k>/
episodes.parquet one row per episode
steps.parquet one row per round (the program the model wrote, its rationale, tool calls, errors)
images.tar the render of every round (WebP q90, original resolution)
raw.tar.zst the original episode.json files (redacted)
gui/<app>/<model>/<condition>/seed<k>/
episodes.parquet one row per episode
steps.parquet one row per GUI step (the model's reply, the executed actions, errors)
images.tar screenshots (WebP q90, 1920x1080), see 4.
raw.tar.zst the original episode.json files (redacted)
<channel>/<app>/_run/<run>/ run-level files: scores.json, run logs, lists of files not saved / not readable
supporting/<experiment>/ the supporting experiments as they were (tables, judgments, manifests)
build_tools/ the scripts that built this repository from the research storage
app: darktable, rawtherapee, gimp, inkscape, blender. model: the short names of the code (qwen35 = Qwen3.5-397B-A17B,
qwen35_27b, glm53, dsv41, step37, nemo35, gpt61sol = GPT-6.1, opus55 = Claude Opus 5.5; GUI agents
holo4_35b, uitars_7b, opencua_72b, guiowl15_32b, evocua_32b, qwen35gui_*, gpt61gui, opus55gui, ...).
Conditions and seeds (original run names)
| condition | original run | what it is |
|---|---|---|
main (program) |
b1t32 (seed0), b1t32_s1 ... b1t32_s4 (seed1-4) |
L1 / L2 / L3, 4 rounds, 32k output tokens |
main (GUI) |
b1g100_s0 ... b1g100_s2 (seed0-2), b1g100_closed (closed models, seed0) |
L1 / L2 / L3, 100 steps |
manual |
b1man |
L2 + the application's manual as a skill (load_topic tool) |
tdiff |
b1tdiff |
L2 + measured TARGET − START difference (table) |
table |
b1table |
L2 + measured statistics of each tool's effect on START |
diffimg |
b1diffimg |
L2 + the difference shown as an image |
minimanual_visual |
b1mmv |
L2 + per-task mini manual with an effect sheet |
minimanual_text |
b1mmt |
L2 + the same mini manual without the sheet |
forced |
b1forced |
L2 / L3, all four rounds forced |
forced_feedback |
b1fb |
forced rounds + numeric distance to TARGET after each render |
The interventions ran on the task subsets listed in the benchmark (minimanual/subsets/<app>.txt). Exact commands and
server flags: the code's docs/conditions.md.
3. Columns
episodes (program): unit, run, condition, seed, app, channel, model, task_id, level (L1/L2/L3), kind (single / multi / long), pass, closeness (1 − ΔE(result, TARGET) / ΔE(START, TARGET)), de00 (mean CIEDE2000 to TARGET), n_rounds, end (done / rounds / error), per_round_closeness, violations, modules_used, modules_true, final_program (JSON), scored, in_paper, paper_use, episode_dir (original path), extra (other fields of the record, JSON).
episodes (GUI): the same identifiers, plus gui_task_id, pass, closeness, de00, d0 (ΔE(START, TARGET)), n_steps, seconds, end (DONE / FAIL / max steps / no valid reply / harness error), modules_used, eval (the evaluator's full output: the tools / filters found in the application and their values, JSON), full_trajectory_saved.
steps (program): episode_dir, model, task_id, level, step (round), kind (program / tool / error), program (JSON), rationale (the model's stated reason, as logged: up to 400 characters), done, violations, tool / topic (manual calls), retries (failed attempts with finish reasons), error, detail, image (path inside images.tar).
steps (GUI): episode_dir, model, task_id, level, step, response (the model's reply; the last 3000 characters as logged), actions (the executed pyautogui code), errors, image (path inside images.tar, null if not saved), screenshot_original (the original file).
What the harness logged, and therefore all that exists: program channel = the parsed program + rationale of every round (not the raw completion text); GUI channel = the last 3000 characters of every reply, the executed actions and a screenshot per step; closed models = tokens and USD per call; open models = no token counts.
4. Screenshots and renders
The GUI runs produced about 10 million screenshots (~5 TB). Saved as WebP (quality 90, original resolution):
| episodes | saved |
|---|---|
| program channel | the render of every round |
| GUI, closed models (GPT-6.1, Claude Opus 5.5) | every step (full trajectory) |
| GUI, every passing episode | every step |
GUI, 5 fixed sample tasks per app (md5(task_id) % 20 == 0), all models / levels / seeds |
every step |
| GUI, all other episodes | the last screenshot (the agent's final state) |
episodes.full_trajectory_saved tells which case applies; steps.image is null for steps whose screenshot was not saved.
GUI episodes that ended within 40 steps were carried from the 40-step runs (b1g_s*, b1g_closed80) into the 100-step
runs (carried_from in extra); their screenshots are taken from the 40-step run (the member path in images.tar is that
original path). Program-channel renders can also be reproduced exactly from final_program / steps.program with the code.
The GUI episodes' work/ directories (the application's runtime state) are not included; the final edit values the
evaluator read from the application are in episodes.eval. A few files could not be read from the storage when this repository was built (storage locks); they are listed in
_run/<run>/unreadable.txt and counted in runs.csv.
5. Cost of the closed models
cost/summary.csv: per model calls, error calls, input / output tokens, USD, first / last call. Claude is priced at
Anthropic's list price; GPT-6.1 at an assumed price (price_assumed = True), so check the provider bill for it.
The ledger uses one name (gpt61sol) for GPT-6.1 in the program and the GUI channel, so its cost is reported for both
together; Claude is split (opus55 program, opus55gui GUI). opus55max (a max-effort pilot) and the dropped trial
models (Grok 4.7, Kimi K3.1) are not in the paper's tables; they are listed so that the total matches the bill.
Totals: models of the paper USD 9,084.83; all calls USD 9,210.11 (180,446 calls).
6. Download only what you need
hf download VanWang/GoldiBench-logs --repo-type dataset --include "*.parquet" --include "runs.csv" --include "cost/*" # all tables (small)
hf download VanWang/GoldiBench-logs --repo-type dataset --include "gui/gimp/gpt61gui/*" # one model on one app, with screenshots
hf download VanWang/GoldiBench-logs --repo-type dataset --include "program/*/qwen35/main/*/*.parquet" # a model's main-table records
from datasets import load_dataset
ep = load_dataset("VanWang/GoldiBench-logs", "episodes_paper")["train"].to_pandas()
ep[(ep.condition == "main") & (ep.channel == "program")].groupby(["model", "level"])["pass"].mean()
The code repository has scripts/download_logs.sh (--channel --app --model --condition --seed --tables-only).
images.tar: tar -xf images.tar (WebP files at their original paths); raw.tar.zst: tar -I zstd -xf raw.tar.zst.
7. How this repository was built (provenance)
From the research storage (read only), with build_tools/: logs.py (per run: parse every episode.json + scores.json
into tables, convert the selected images to WebP, pack the non-image files), regroup.py (split each run into
<channel>/<app>/<model>/<condition>/seed<k>/), finalize_logs.py (episodes_paper, runs.csv, cost, this README),
redact.py (machine-specific information removed: storage paths <ROOT>, host names <HOST>, cluster IPs <IP>,
user names <USER>, e-mail addresses <EMAIL>, keys <REDACTED>; only counts were recorded, never the values).
Original paths are kept (redacted) in episode_dir / screenshot_original / tar member names, so every record can be
traced back to the run it came from.
中文摘要
- 只保存论文里的实验:主表(程序通道 5 个 seed、GUI 通道 3 个 seed 和闭源模型),第 5 节的干预实验,第 4 节的验证实验,第 2 节的动机实验,论文数字的计算结果,以及闭源模型的花费。smoke 测试、pilot、弃用或做错的 run、备份都不保存。
- 目录:
<program|gui>/<应用>/<模型>/<条件>/seed<k>/,每个目录下有episodes.parquet(每个 episode 的结果)、steps.parquet(每一轮/每一步的模型输出和动作)、images.tar(渲染图/截图)、raw.tar.zst(原始记录)。条件和原始 run 名的对照见第 2 节的表。 - 截图:程序通道全保存;GUI 的闭源模型、通过的 episode、每个应用 5 个抽样任务保存完整轨迹,其余只保存最后一张;文字全部保存。
- 花费:见
cost/。论文用到的模型合计 $9,084.83,所有调用合计 $9,210.11。GPT-6.1 的程序和 GUI 调用在账本里分不开,单价是估算的。 - 下载:可以按目录挑着下,见第 6 节,或用代码仓库的
scripts/download_logs.sh。
- Downloads last month
- -