/
Copy Bench

Copy Bench method

Copy Bench scores how close a model's rebuild of a web component gets to the original when all it has is a few seconds of screen recording. Every model copies 50 components twice, first blind and then with a browser, and two judges from different labs grade each copy.

How it works

The tasks

50 hard components no model recognized: WebGL, shaders, animations and small games.

What models get

A 4โ€“8 second recording and a tool to pull frames from it.[1]

Task prompt ยท Neon Loop
# Task: copy a web page Recreate the original page as one HTML file, as close to it as you can. ## What you get - `video.mp4`: a screen recording of the original page, 1280x800, 25 fps, 8 s from the load event. - `cb-frames` (run it with Bash) pulls frames out of `video.mp4` as PNGs into `more-frames/`: `cb-frames --sheet` makes one overview picture with 16 time-labelled thumbnails over the whole video, `cb-frames --at 0.5,1.25` gives full-size 1280x800 frames at those seconds, `cb-frames --fps 25 --from 1 --to 2` every frame in a window. Open the PNGs with your file-read tool to see them as images (don't decode pixels with scripts). `cb-frames --help` shows the rest and the video's length. ## The page The page moves on its own: animation that plays on load and/or loops. Also in the workspace: - `steps.json`: the mouse / scroll script that drives the page during the capture (below). ## How the capture works (the original's and yours) - Headless Chromium, viewport 1280x800, device scale factor 1, light colour scheme, locale en-US, timezone UTC. - Screenshot: a fresh page, after the load event, network idle (capped at 5 s) and fonts ready. - Recording: the page is loaded again and recorded for 8 s; time zero is the load event (real clock; with a mouse script, just after a short mouse warm-up that follows the load event). Frames are cut from that recording. - During the recording `steps.json` drives the input. Each step has `at_ms` (ms after time zero) and `do`: `move` = move the mouse to `x,y` (viewport px) in `steps` small hops; `scroll` with `y` = set the window scroll to `y`, with `dx,dy` = a mouse-wheel turn; `click` = click at `x,y`; `down` / `up` = press / release the left button where the mouse is (a drag); `wait` = nothing. - The red dot with a white ring is the mouse cursor, drawn by the capture tool on top of the page. It isn't part of the page: don't draw it. - The screenshot is taken without any mouse or scroll input. ## Output Write ONE self-contained file: `index.html` at the workspace root. - Inline your own HTML, CSS and JS. No build step: the file is opened as is. - Libraries only from esm.sh, unpkg.com, cdn.jsdelivr.net or cdnjs.cloudflare.com (script tags or ES module imports). No other external URLs: no images, fonts, videos or data from any other host. Local files only from `assets/`. Draw or inline anything else (CSS, SVG, canvas, data URIs), or use a close system font. - Your file is opened in Chromium at 1280x800 and captured exactly like the original, then compared with the original's capture frame by frame. - Don't ask questions. When something is unclear, make your best guess and finish the file. Goal: as close as you can get to the original in layout, colour, typography, text and motion. Closeness counts, not whether you think your version looks better. --- ## Where you are Your working directory is `/workspace`, and everything listed under "What you get" is there: `video.mp4`, `steps.json`. There's no browser here and no internet (only the library CDNs): you can't open or render your page, so don't try to install one. - Write your copy to `/workspace/index.html`. - Hard rule: your page draws everything itself. Don't put the video, frames or screenshots (or pieces of them) into the page, as files or as data URIs. Only the images in `assets/`, if there are any, may be used as images. - You have 30 minutes. Whatever is in `/workspace/index.html` when the time runs out is what gets graded, and no file scores zero. Write a first full version early, then improve it.
Original: Neon Loop
Original
The real prompt, and the recording the model starts from.

The models

Each runs in its maker's own agent: Codex, Claude Code, Gemini CLI and so on.

One-shot, 30 min

There's no browser in the sandbox, so the model copies blind.

Self-verified, 20 min

Same session, now with a browser to check and fix the copy.[2]

Scoring

GPT-6.1 Sol and Claude Opus 5.5 grade every copy, and we average them.

What the judges see

Original, copy and a diff side by side: the settled page, frames at four moments and the whole timeline. The copy can shift up to 120 ms to line up in time.

Two rows of ORIGINAL, COPY and DIFF panels at 2500 ms and 7500 ms
Neon Loop, GPT-6 Astra, self-verified: two of the sheets the judges get.

From checklist to score

26 checks in five groups, each answered same, minor or major. Code does the math: a group starts at 100 and loses 15 per minor, 40 per major.

Content25%Layout25%Motion20%Color15%Type15%

Three looks before a major counts

Any major gets a second look. If the two disagree on a major, a third look breaks the tie, check by check. GPT-6.1 Sol grades each copy three times and we keep the median; Opus looks once.

How much to trust it

Each judge agrees with itself at 0.95 or better and with the other at 0.85, and their average matches 249 hand-scored copies at 0.84.

What scores zero

Pasted code, loading the original, faked motion (a video or flipped frames) and no file.

Limits

Judge bias

The GPT judge gives GPT models about 4 points more than Claude does, and averaging judges from two labs halves that.

Rerun noise

A rerun can move one task 10 to 19 points, so single-task gaps mean little.

Hand scoring

One person did the hand scoring, on 23 of the 50 components, and saw the GPT judge's score first.

WebGL in the public tasks

The reference recordings were made on macOS with GPU rendering. In a Linux sandbox Chromium draws WebGL and shaders in software, so a correct WebGL copy can look a little different from the reference. Our published results were captured on the same machine for both sides, so they don't have this problem.

Data and code

13 of the 50 tasks are public on GitHub. They run on Valkyrie as copy-bench/copy-bench@v1. The other 37 stay private so the benchmark stays useful.

Notes

  1. [1]

    We tried other inputs on Claude Opus 5.5 and Sonnet 5.5:

    • Screenshot: motion scored 5 or less out of 100 on 83% of 136 copies. The ones that got motion right worked from memory. On Magic UI's animated list, the agent wrote: "The screenshot looks like Magic UI's animated-list demo, so I matched it to that."
    • Same frames (2 per second) without the mp4: Sonnet 62.5 vs 49 with it, Opus 54 vs 49. That's within run-to-run noise, so the mp4 itself adds nothing.
    • Live URL: the model pasted the original's own code in 34 of 68 copies.
  2. [2]

    The browser is agent-browser. 153 of 1,400 steps hit the time limit; they're scored on whatever file was there.

See the results โ†’