Dataset Viewer
Auto-converted to Parquet Duplicate

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.

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
-