README.md

metadata

pretty_name: Cutaste — public benchmark (base-2026Q4.1-preview)
license: other
license_name: mixed
license_link: LICENSE.md
task_categories:
  - text-generation
language:
  - en
tags:
  - benchmark
  - evaluation
  - frontend
  - web-design
  - aesthetics
  - code-generation
  - coding-agents
size_categories:
  - n<1K
dataset_info:
  features:
    - name: task_id
      dtype: string
    - name: family_id
      dtype: string
    - name: category
      dtype: string
    - name: page_type
      dtype: string
    - name: brief
      dtype: string
    - name: measures
      dtype: string
    - name: requirement_points
      list:
        - name: id
          dtype: string
        - name: text
          dtype: string
    - name: viewports
      sequence: string
    - name: source
      dtype: string
    - name: source_id
      dtype: string
    - name: license
      dtype: string
  splits:
    - name: test
      num_bytes: 57996
      num_examples: 40
  download_size: 17982
  dataset_size: 57996
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/test-*

Cutaste — public benchmark (base-2026Q4.1-preview)

What this is. The benchmark half of Cutaste's public baseline: a fixed set of single-page web tasks for coding agents, plus the rules they are scored by (render contract, check definitions, judge snapshot). No results are stored here. The maintainer's results for this release (report, per-task results, judge admission, the generated pages) are in the separate dataset Validflow/cutaste-base-results under the same tag base-2026Q4.1-preview.

• Release: base-2026Q4.1-preview (preview channel: scores are not promised to be comparable across versions)
• Tasks: 40, from WebGen-Bench (test split, revision c061fe8, MIT); see Relation to WebGen-Bench
• Configurations under test: defined in standard/configs/ (their results are in the results dataset)
• Versions are git tags: the tag base-2026Q4.1-preview pins this release (use revision="base-2026Q4.1-preview"); main always holds the newest release
• Planned: registration as a Hugging Face Benchmark (eval.yaml) once our evaluation framework can be listed

Page category	Tasks
app-ui	19
content-reading	9
e-commerce	6
marketing-landing	3
portfolio	3

Folder structure

README.md                         this card
LICENSE.md                        licences (mixed, see below)
data/test-00000-of-00001.parquet  the tasks as one table (config "default", split "test"; dataset viewer)
tasks/<family>/                   one folder per task, the files the cutaste CLI reads (see "Files of a task")
  task.md  measures.json  source.json  original.json  ui-instruct.json
standard/                         the scoring rules
  render-contract.json            render contract (browser, viewports, frozen clock, network off, font pack) and its hash
  checks.json                     floor checks: id, version, severity, what each one detects
  baseline-selftest.json          floor-check self-test on injected defects (recall / false-positive rate)
  requirement-checkers.json       requirement-point checkers and the point mapping rules
  judge-snapshot.json             frozen auto-judge rules: template, criteria, judge model, image policy, hash
  configs/<config>.json           configurations under test (harness, model, skills with pinned commits, fingerprint)
selection.json                    how the 40 tasks were picked (seed, candidate pool, list)
anchors/                          anchor tasks (README: none ship in this preview)
ledger/
  license-ledger.jsonl            one licence record per task (source, licence, evidence, packaging)
  sources.lock.json               pinned source files with sha256
  REBUILD.md                      how the maintainer rebuilds this release
LICENSES.md  NOTICE  CHANGELOG.md
prereg.json                       sha256 of every input file (tasks, rules, selection); `createdAt` says when it was frozen
manifest.json                     prereg hash + sha256 of the other files
SHA256SUMS                        sha256 of every file (sha256sum -c compatible)
assets/fonts/v1/                  font pack pinned by the render contract (fonts/, licenses/)

Fields of data/test-00000-of-00001.parquet (one row per task)

Field	Type	Meaning
task_id	string	Task card id, e.g. card-webgen-000008-v1 (task_id in the results tables)
family_id	string	Task family id, e.g. fam-webgen-000008 (folder name under tasks/ here and pages/<config>/ in the results)
category	string	Our page category: one of marketing-landing, content-reading, portfolio, e-commerce, app-ui, data-dashboard
page_type	string	WebGen-Bench application_type, verbatim
brief	string	The task text, verbatim WebGen-Bench instruction
measures	string	One sentence saying what the task measures (ours)
requirement_points	list of {id: string, text: string}	Points decidable on one static page; text = original UI test task + " Expected: " + expected_result, verbatim
viewports	list of string	Viewports the page is rendered and judged at (desktop-1440x900, mobile-390x844@2x)
source	string	Source benchmark and revision
source_id	string	Item id in the source benchmark (WebGen-Bench id)
license	string	Licence of the task text (from ledger/license-ledger.jsonl)

Files of a task (tasks/<family>/)

File	Content
task.md	YAML front matter + body. Front matter: id (task card id), familyId, scenario (frontend-aesthetic@1), locale, measures, requirementPoints (list of id, text, checker — fe.dom for DOM/colour assertions, fe.vlm for screenshot checks — and origin, e.g. original:ui_instruct-5 = index into the original test cases), category, pageType, promptType, track (single-page), viewports, requiredSections, source (source.json). Body: the brief, verbatim.
measures.json	What the task measures: target (path, text), origin (benchmark and original id), requirementPoints (ids), difficulty, gap, hiddenDimension (null for imported tasks), generatedBy (importer, seed).
source.json	Provenance: kind (public), benchmark, revision, originalId, label (recognized), ledgerRef (its line in the licence ledger), original (sha256 of the original record), packaging (bundled).
original.json	The original WebGen-Bench record, unchanged: id, instruction, Category, application_type, ui_instruct (every original UI test case).
ui-instruct.json	How the original UI test cases were used: total, kept, and notApplicable (index, task, expectedResult, reasons) for the cases that need multi-step interaction, a backend or persistence.

How to read it

1. In the browser. The dataset viewer shows the task table (config default, split test; the viewer works on public datasets). Files and versions shows every file; pick the tag base-2026Q4.1-preview in the branch selector to see exactly this release, and open tasks/<family>/task.md for one task.

2. Python.

from datasets import load_dataset

tasks = load_dataset("Validflow/cutaste-base", split="test", revision="base-2026Q4.1-preview")   # 40 rows
print(tasks[0]["task_id"], tasks[0]["requirement_points"])

# the whole release as files (task folders, rules, prereg, checksums)
huggingface-cli download Validflow/cutaste-base --repo-type dataset --revision base-2026Q4.1-preview --exclude "assets/*" --local-dir taste-base
cd taste-base && sha256sum -c SHA256SUMS

While the dataset is private, log in first (huggingface-cli login or HF_TOKEN).

3. Score your own agent with the cutaste CLI.

npm i -g cutaste           # command: cutaste
cutaste base pull                # download and verify this benchmark (tasks + rules)
cutaste base run --config <your-config> --quick   # plan → confirm in your paired browser → runs your agent
cutaste base report              # downloads the maintainer's results from Validflow/cutaste-base-results, verifies them, shows them next to yours

cutaste base run re-renders the public configurations' pages on your machine and compares them with yours, so differences between two machines' renderers do not enter the comparison.

Same rules, comparable scores

A score is only comparable to another score produced under the same rules. The rules of this release:

Rule	This release	Recorded in
Scenario	frontend-aesthetic@1.0.0	standard/configs/*.json (scenario), every evaluation (scenario, scenarioVersion)
Render contract	sha256:ec7629d3c0a40e081293b5ff99c018f1ecc459a4f79206f1a223e0bdd9b0006b	standard/render-contract.json; contractHash of every evaluation
Font pack	taste-fontpack v1, manifest sha256:7c2f9985a470064a1d87e147fc6ebff7c928422d9375212657bb9a042f3f1a2c, files at commit 5842d42078a0	assets/fonts/v1/ (part of the render contract)
Floor checks	fe.no-output@1 (fatal), fe.blank-page@1 (fatal), fe.horizontal-scroll@1 (severe), fe.text-overflow@2 (severe), fe.overlap@2 (severe), fe.contrast@2 (severe), fe.contrast-aa@1 (minor), fe.broken-image@1 (severe), fe.required-sections@1 (severe), fe.fabrication@1 (minor), fe.console-errors@2 (severe), fe.external-requests@1 (severe), fe.font-fallback@1 (minor), fe.small-text@2 (minor)	standard/checks.json
Requirement checkers	fe.dom@2, fe.vlm@1; point mapping fe-points@2	standard/requirement-checkers.json
Evaluation pipeline	1	evaluation cache key
Judge snapshot	sha256:2cb205f0177ed401766f7174e4798b814aa50ff5997d5c9dc8f3ef77cf8cd69b (J-2026Q4; template fe.pointwise.public@1, criteria hierarchy, typography, layout, contrast-harmony, consistency, brief-fit; judge codex-cli gpt-6.1-sol (medium))	standard/judge-snapshot.json
Configurations under test	codex-frontend-design (gpt-6.1-sol), codex-impeccable (gpt-6.1-sol), codex-plain (gpt-6.1-sol)	standard/configs/ (fingerprint = hash of the resolved config)

• The render contract fixes the browser settings, viewports, frozen clock, network-off policy, full-page limit and the pinned font pack; its hash changes whenever any of them changes. Every evaluation in the results dataset records the contract hash it was rendered under (contractHash).
• The floor checks and requirement checkers are versioned one by one; an evaluation records the version of every check that ran.
• The judge snapshot (judge/snapshot.json) freezes the pairwise prompt template, the criteria, the judge model and reasoning effort and the image policy; its hash covers all of them. The aesthetic estimate in any report is only shown when the snapshot it was judged with has this hash and was admitted.
• standard/render-contract.json is frozen with the tasks: its sha256 is in prereg.json (frozen 2026-10-21T10:21:49.921Z).

Use a cutaste CLI that implements these rules: scenario frontend-aesthetic@1.0.0 with the render contract and judge snapshot above — for this release, the cutaste CLI built from Cutaste commit 38060699e6dd. Every local evaluation records the scenario version, check versions and contract hash it used, and when your judge snapshot differs from this release's, cutaste base report says so and shows no aesthetic numbers.

Relation to WebGen-Bench

• Selection. 40 of the 101 WebGen-Bench test tasks, stratified by our page category, fixed seed. The seed, the candidate pool and the list are in selection.json; the pinned source file and its sha256 in ledger/sources.lock.json.
• Briefs are verbatim: 40/40 byte-identical to WebGen-Bench instruction at revision c061fe8.
• Requirement points: of the 264 original UI test cases for these tasks, 72 are kept — those decidable on one static page (e.g. colours, required text); their text is the original task + " Expected: " + expected_result, verbatim. The other 192 (multi-step interaction, backend, persistence) are marked not applicable.
• Added fields: category (mapped from Category / application_type to our 6 page categories), page_type (= application_type), measures (one sentence, ours), viewports.
• Different task framing. WebGen-Bench evaluates functional multi-page websites with a GUI agent. Cutaste asks for one self-contained static page (no network, interactions simulated client-side) and scores floor defects, requirement compliance and pairwise aesthetics. Scores are not comparable to WebGen-Bench scores.
• Nothing is lost: each task keeps the original record (original.json) and every original UI test case (ui-instruct.json).
• What agents receive: the brief plus the scenario's fixed page facts and sandbox rules. The sandbox rules, verbatim:

Sandbox rules (frontend-aesthetic, single page)

You are building one static web page. Follow these rules exactly.

1. Write the page to out/index.html. Only files inside out/ are collected.
2. You may add CSS, JavaScript and image files under out/ (for example out/styles.css, out/app.js, out/images/hero.svg) and reference them with relative paths.
3. The page must be fully self-contained and work offline:
   • no network access while building or viewing;
   • no external CDNs, script tags, stylesheets, web fonts or images from other hosts;
   • no http:// or https:// URLs in src, href, url() or @import.
4. Fonts: use local font stacks (for example system-ui, sans-serif, Georgia, serif) or font files you place under out/. Do not link to font services.
5. Images: draw them with inline SVG or CSS, or put files under out/. Every <img> needs an alt text and explicit width and height.
6. There is no backend. Simulate interactive features (search, filters, forms, tabs, carts) with front-end JavaScript and in-page data only.
7. The page is viewed at desktop 1440x900 and mobile 390x844 (device pixel ratio 2). It must look intentional at both sizes with no horizontal scrolling.
8. Use only the content you are given. Do not invent facts, numbers, names, prices, quotes, testimonials, ratings or logos that are not in the task.
9. Mark the root element of each required section with data-section="<name>".
10. Do not use a build step or package manager; ship plain HTML, CSS and JavaScript.

Licences

• Tasks (data/, tasks/): from WebGen-Bench, MIT License, © the WebGen-Bench authors (texts verbatim; attribution in LICENSES.md).
• assets/fonts/v1/: each font under its own licence (texts in assets/fonts/v1/licenses/): SIL Open Font License 1.1, Bitstream Vera Fonts licence.
• Everything else written by Cutaste (cards, rules, configurations, ledger, tables): CC BY 4.0.