mirasim-ai/devbrowse-bench

DevBrowse Bench v1

DevBrowse Bench measures browser use in development work: a coding agent changes a web app, then checks its own work in a browser. It compares browser tools, not models. Each task runs twice at the same time, with the same model, the same prompt and the same starting code; the only difference is the browser tool the agent is told to use. The result is a relative change with a 95% interval, not a standalone score: models drift from day to day, so an absolute number from one run does not carry over, while a difference measured in pairs at the same moment does.

• Open tasks and judges. Every ticket, seed patch, reference solution and judge is in this dataset repository, along with 217 audit variants that test the judges. Nothing is hidden or encrypted; every judge is open, rule-based code, and you can read why any run passed or failed.
• Real frontend work, run locally. The agent edits a React + Vite app with a mock API, or a real open-source project (Excalidraw, Lexical, tldraw, react-admin) at the commit before a merged fix, on your own machine.
• Paired runs with intervals. Both tools run the same task side by side, 3 to 5 times each; results are reported as relative changes with 95% intervals from resampling tasks.

v1 compares Mirasim Computer Use with ChatGPT Computer Use (the in-app browser of Codex in the ChatGPT desktop app) on 60 tasks, 200 paired runs. Other browser tools are not part of v1. Mirasim Computer Use is an open-source MCP server: github.com/mirasim-ai/computer-use, on npm as @mirasim/computer-use.

Everything is here, in one place: the per-run data and the task list (the two tables in the viewer), the full report, and the code that produced them: task definitions, judges, reference solutions, judge audit variants, the app under test and the scripts that run and score a pair. See Files and Running it.

Results

Model gpt-6.1-sol, medium reasoning effort, Codex 0.167.0-alpha.3.2 in the ChatGPT desktop app 26.1103.31037; Mirasim Computer Use 0.1.0-rc.5. 60 tasks, 200 runs per side, run on 2026-11-06 and 2026-11-07. The headline numbers are totals over all 192 pairs where both sides passed. The three panels split them into the three parts of the suite: the classic and extended tasks on Team Tasks, a simulated project written for this benchmark (44 tasks); the interaction tasks ★ on the same project, bugs where a control the user can see cannot be clicked (7 tasks); and real projects, merged bug fixes from four open-source repositories (9 tasks).

These numbers describe the two tools as they were on those two days. Around the end of the runs, ChatGPT Computer Use changed how it uses the browser and began to need fewer model requests per run. When 39 of the 60 tasks were run again the same way on 2026-11-10 and 2026-11-11, with a later release of Mirasim Computer Use, the time saving on them was about −16%, against −25% for the same tasks here. That rerun is not part of v1.

	ChatGPT Computer Use	Mirasim Computer Use
Runs passed	192 / 200	196 / 200

Over the 192 pairs where both sides passed (change = Mirasim total / ChatGPT total − 1; 95% interval from resampling tasks):

Metric	Change	95% interval
Time	−26%	−32% to −20%
Model requests	−45%	−48% to −42%
Input tokens	−50%	−54% to −46%
Output tokens	−8%	−13% to −3%
Browser calls	−37%	−41% to −32%

The saving holds in each part: time −26% on the classic and extended tasks of Team Tasks, −29% on its interaction tasks ★, −19% on the real projects. Mirasim Computer Use finished sooner in 172 of the 200 pairs, and on average in 55 of the 60 tasks:

All tables, failures, per-action and per-task numbers are in the report: results/v1/REPORT.md. npm run report recomputes it from the per-run data (Running it).

Data

Two tables, shown in the dataset viewer and loadable with datasets:

from datasets import load_dataset

runs = load_dataset("mirasim-ai/devbrowse-bench", "runs", split="train")    # 400 rows
tasks = load_dataset("mirasim-ai/devbrowse-bench", "tasks", split="train")  # 60 rows

runs (400 rows)

data/runs.jsonl, the same file as results/v1/runs.jsonl. One row per run: 60 tasks × 3 or 5 runs × 2 sides. Two rows with the same task and rep are a pair, run at the same time.

Field	Meaning
task, part, group, actions, rounds	Task id, suite part (classic, extended and interaction are on Team Tasks, the simulated project; real is the real open-source projects), group, browser actions its check needs, number of prompt rounds
arm	chatgpt (ChatGPT Computer Use) or mirasim (Mirasim Computer Use)
rep, pair_order	Run number; which side's prompt was sent first (alternates by run)
status, pass, verdict	pass / fail / error; the judge's reason when not passed
rejudged	When judges changed after the start, the original verdict (original_pass) and whether it changed
relaunches	Times the pair was discarded and rerun because sending the prompt failed
started_at	Start of the first round (UTC)
duration_s	Sum over rounds of task start → task complete, from Codex's session record; waiting between rounds is not counted. wall_span_s includes it
turns	Per round: duration, model requests, input and output tokens
model_requests, input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens, max_context_tokens	Model usage
tool_calls, browser_calls, browser_turns, browser_span_s, browser_tool_wall_s	All tool calls; browser-tool calls (counting each call inside code-mode exec); tool calls that contained a browser call; time from the first to the last browser call; time the browser tool reported for itself
files_changed	git diff --stat summary of the agent's change
model, reasoning_effort, codex_version, chatgpt_version, mirasim_cu_version	Environment of the run (chatgpt_version for v1 was read from the desktop app's logs)
stability	Mirasim side only: closeTab calls and scripts that stopped early, by reason

Conversation text, the agent's messages, code changes and local paths are not included.

tasks (60 rows)

data/tasks.jsonl, exported from the task definitions by analysis/export-tasks.ts.

Field	Meaning
id, title, part, group, kind, actions, runs_per_side	Identity and classification
project	Team Tasks (the simulated React + Vite app in apps/team-tasks/) or the upstream repository
rounds	The ticket text of each round, as sent (docs/tasks.md shows the wrapping prompt and the one sentence that differs between the sides)
seed, seed_edits	What the seed patch does to the app before the agent starts
agent_scenario, judge_scenario, judge_viewport	Mock API scenario while the agent works and while judging (JSON strings), judging viewport
judge	What the rule-based judge does and requires
reference	The reference solution the self-test must pass
audit_variants	Number of audit variants that must fail / must pass
license, pr, base_commit, merge_commit, fix_paths, app_dir	Real projects: upstream license, the pull request that fixed the bug, the commit the agent starts from, the fix, the app directory

The tasks

60 tasks, each a ticket written the way a user or teammate would write it: bugs come with steps to reproduce, features are described in the words of the UI, and the code location is never named. Every prompt ends by asking the agent to check the result in a browser before finishing.

Part	Tasks	Runs per side	What it is
Team Tasks · classic	20	3 each	Team Tasks is the simulated project: a React + Vite task manager with a mock API, written for this benchmark. Classic tasks are multi-round features, cross-page changes, regressions, async bugs and QA passes
Team Tasks · extended	24	3 each (long features 5)	On the same project: layout, UI, complex controls, browser features (upload, download, clipboard, new tabs), navigation, auth, payments, debugging, three long features
Team Tasks · interaction ★	7	5 each	On the same project: bugs where a control the user can see cannot be clicked (overlays that swallow clicks, stretched links, a sticky toolbar covering Save, a clipped menu). Marked ★ and reported on their own
Real projects	9	3 each	Not written for the benchmark: merged bug fixes from four open-source projects (Excalidraw, Lexical, tldraw, react-admin); the agent works on the commit just before the fix

The full list with what each judge checks: docs/tasks.md.

How it is judged

Every judge is a rule-based check, with no model involved. After the agent finishes, the judge starts the app the agent left behind and drives it in headless Chrome the way a user would (real mouse coordinates and hit testing, keyboard, scrolling, resizing, reloads, file pickers), then checks the page and the data stored in the mock API. QA tasks, where the agent writes a report instead of code, are judged by matching report entries against rules.

Judges are tested in two ways. Every Team Tasks task must fail on the seeded app and pass on a reference solution (npm run selftest), and 217 audit variants (plausible but wrong implementations, and unusual but correct ones) check that judges neither let wrong work through nor reject right work (npm run audit). Real-project judges must fail on the base commit and pass on the upstream fix. Judges changed after the runs began were applied to both sides; 14 verdicts changed, 8 from fail to pass and 6 from pass to fail (the 6 runs of react-admin-11342), all listed in results/v1/judge-changes.md. Details: docs/judging.md.

How a pair is run

Both sides run at the same time on one Mac, each with its own copy of the code, its own mock API and its own dev server, each in its own Codex conversation in the ChatGPT desktop app. The two prompts differ only in the sentence that names the browser tool. Which side gets its prompt first alternates from run to run. Prompts are sent through the ChatGPT window by a script; sending is not timed, because time, model requests and tokens are read from Codex's own session record. A pair where sending failed is discarded and run again as a whole. Details: docs/methodology.md; how the intervals are computed: docs/statistics.md.

Running it

Download the whole repository, then work in it like any Node project:

pip install -U huggingface_hub
hf download mirasim-ai/devbrowse-bench --repo-type dataset --local-dir devbrowse-bench
cd devbrowse-bench

Requirements: Node 22 or later, Python 3, git. Judging and self-tests run on macOS and Linux; running agent pairs needs macOS with the ChatGPT desktop app (docs/running.md).

npm ci
npm run setup                                   # app dependencies and Playwright's Chromium
npm run selftest -- -j 2 due-dates scroll-tail  # judge self-test for some tasks (all 51 without ids)
npm run audit -- -j 2 assignee                  # audit variants of a task (all 217 without ids)
npm run report                                  # recompute the report from results/v1/runs.jsonl
npx tsx harness/run-real-pair.ts --task react-admin-11310 --dry          # real project: base must fail
npx tsx harness/run-real-pair.ts --task react-admin-11310 --dry --fixed  # the upstream fix must pass

v1 judged Team Tasks with Chrome for Testing 153.0.8010.12 and the real projects with the installed Google Chrome; CHROME_PATH picks a specific Chrome for both. Real projects are cloned from upstream into .cache/real-projects/ on first use and installed with each project's own package manager (Corepack).

Files

Path	Contents
data/	The two tables above: runs.jsonl and tasks.jsonl
results/v1/	The report (REPORT.md), judge changes, and the per-run data the report is computed from
docs/	Methodology, judging, statistics, task list, how to run pairs, judge audit notes; docs/images/ has the result figures in English and Chinese
suites/v1.txt	The 60 task ids
tasks/	Task definitions: tickets, seed patches, backend scenarios and judges (index.ts lists them all; descriptions.json summarises each)
judges/real-projects/	Judge scripts for the real-project tasks
references/	Reference solutions used by the self-test
audit-variants/	217 judge audit variants (why.md says what each one gets wrong or right)
apps/team-tasks/, apps/mock-api/	The simulated project the agent works on, and its mock API (the agent only sees the app and its API.md)
harness/	Self-test, audit, pair runners, prompt sender, rollout reader, re-judging
scripts/	Batch runs and the v1 schedule
analysis/	Export of results and tasks, the report
images/	The three figures on this page (the same files as the English ones in docs/images/)

Limitations

• One machine, one model, one reasoning effort, two tools. 6 of the 400 runs (3 per side, never both runs of a pair) turned out to have run at low reasoning effort; the report also gives the totals without those pairs, which move no change by more than one percentage point.
• The ChatGPT desktop app updates itself. Every v1 run happened on 26.1103.31037 (checked against the app's logs); the runners now record the version in each result.
• Real-project tasks are fixed bugs from public repositories, so a model may have seen the fix. They were picked from fixes merged between July and November 2026.
• The suite favours tasks where checking in a browser matters. It does not measure overall coding ability, and there is no leaderboard.

Versions

v1 is this release: the 60 tasks and the runs above. v2 will add a second simulated project and more real-project tasks.

License and citation

Two licenses, by kind of file:

• Data and text: CC BY 4.0. The task texts (tickets and follow-up rounds), task descriptions, results (data/, results/), documentation (docs/, this page) and figures.
• Code: MIT. The harness, scripts and analysis, the judge code in the task definitions, the reference solutions and audit variants, and the simulated project with its mock API.

Real projects are not included; they are fetched from their upstream repositories under their own licenses (MIT for Excalidraw, Lexical and react-admin; the tldraw license for tldraw).

@misc{devbrowsebench2026,
  title  = {DevBrowse Bench: paired measurement of browser tools for coding agents},
  author = {{MIRASIM, INC.}},
  year   = {2026},
  url    = {https://huggingface.co/datasets/mirasim-ai/devbrowse-bench},
  note   = {Version 1}
}