README.md

---
pretty_name: Co-Design Bench — Public ME-96
tags:
  - arxiv:2610.35138
  - benchmark
  - multimodal
  - coding-agents
  - web-development
size_categories:
  - n<1K
configs:
  - config_name: tasks
    default: true
    data_files:
      - split: test
        path: data/tasks.parquet
  - config_name: rubrics
    data_files:
      - split: test
        path: data/rubrics.parquet
---

<p align="center">
  <img src="assets/logo.png" alt="Co-Design Bench mascot" width="108" />
</p>

<h1 align="center">Co-Design Bench</h1>

<p align="center"><strong>Multimodal Collaborative Coding Evaluation for Agentic Models</strong></p>

<p align="center">
  <a href="https://codesignbench.github.io/">Project website</a> ·
  <a href="https://arxiv.org/abs/2610.35138">Paper</a> ·
  <a href="solve_norubric.tar.gz">Solver inputs</a> ·
  <a href="eval_withrubric.tar.gz">Evaluation inputs</a> ·
  <a href="#citation">Citation</a>
</p>

![Co-Design Bench overview, showing the full evaluation and public release scope](assets/overview.png)

Co-Design Bench evaluates whether coding agents can translate real users'
multimodal requests into complete, working revisions of existing applications.
Each task provides a runnable starting application, a user request, an annotated
screenshot, and any additional media. Fixed expert-authored acceptance criteria
assess the requested changes and preservation constraints using source and
browser evidence.

## Dataset scope

This release contains **96 Multimodal Editing (ME) tasks and 521 acceptance
criteria**. Repository Editing (RE) tasks are outside this release.

The paper evaluates 273 tasks across 100 ME and 173 RE tasks, with 2,331 criteria.
The overview illustrates that full evaluation; this dataset is its public ME
subset. Results on these 96 tasks should identify that scope explicitly and be
reported separately from the paper's full-set leaderboard.

| Primary attachment | Tasks |
| --- | ---: |
| Audio | 32 |
| Video | 24 |
| Document | 16 |
| Image | 4 |
| No extra attachment | 20 |
| Total | 96 |

Tasks without an extra attachment still include the request, starting
application, and annotated screenshot.

## Files

| File | Contents |
| --- | --- |
| [Solver archive](solve_norubric.tar.gz) | Applications, user requests, annotations, and attachments for all 96 tasks, without rubrics. |
| [Evaluation archive](eval_withrubric.tar.gz) | The same task inputs, with each task's fixed `rubric.json`. |
| [Task index](data/tasks.parquet) | 96 task records, including annotation previews; available as the default `tasks` configuration. |
| [Rubric index](data/rubrics.parquet) | 521 criterion records; available as the evaluator-only `rubrics` configuration. |
| [Rubric exports](rubrics/) | CSV, JSONL, and grouped JSON exports of the fixed public criteria, with their case list. |
| [Original rubric package](CoDesignBench-ME-96-Rubrics-521.zip) | Original per-task rubric JSON files for all 96 tasks. |
| [Manifest](manifest.json) | Public scope, case IDs, counts, and archive checksums. |
| [SHA-256 checksums](SHA256SUMS) | File integrity checks for this release. |
| [Citation metadata](CITATION.cff) | Paper authors and arXiv citation. |

The Parquet files provide indexes for browsing and analysis. Download an archive
to obtain the application source and media required to run the benchmark.
The `rubrics/` directory contains `rubrics_521.csv`, `rubrics_521.jsonl`, and
`rubrics_by_task.json`, plus the fixed case list. The original 96 individual
`rubric.json` files are preserved in the evaluation archive and the original
rubric ZIP above.

## Data fields

Both configurations use a single `test` split; these are benchmark evaluation
tasks. The `tasks` configuration contains solver inputs and metadata:

| Field | Type | Description |
| --- | --- | --- |
| `case_id` | string | Original task ID. |
| `benchmark_track` | string | `ME` for every task in this release. |
| `request` | string | Original `user_queries.json[0].text`, preserved verbatim. |
| `query_path` | string | Path to `user_queries.json` within an extracted archive. |
| `project_path` | string | Path to the starting application within an extracted archive. |
| `annotation_path` | string | Original annotation path under `cases/<case_id>/project/_annotations/`. |
| `annotation_image` | Image | Original annotation PNG embedded for dataset viewer previews. |
| `attachment_paths` | list of strings | Additional attachment paths within an extracted archive. |

All paths are relative to the archive's extraction directory. Additional
attachments remain inside the archives; the annotation preview does not replace
the full task inputs. The `tasks` index contains no acceptance criteria.

The `rubrics` configuration contains one row per evaluation criterion:

| Field | Type | Description |
| --- | --- | --- |
| `rubric_id` | string | Criterion record ID. |
| `case_id` | string | Original task ID, matching the task index. |
| `task_id` | string | Original task identifier from the rubric. |
| `benchmark_track` | string | `ME`. |
| `criterion_index` | int64 | Criterion position within its task, starting at 1. |
| `criterion` | string | Original criterion text, preserved verbatim. |

Rubric rows are evaluator inputs. Keep them separate from the solver's context.

## Load the indexes

Install the Hugging Face datasets library:

```bash
python -m pip install datasets
```

With a local copy of this dataset repository, load the task index from its root:

```python
from datasets import load_dataset

tasks = load_dataset(
    "parquet", data_files={"test": "data/tasks.parquet"}, split="test"
)
print(tasks[0])
```

After this package is uploaded to Hugging Face, replace
`<your-org>/<your-dataset>` below with the actual dataset repository ID:

```python
from datasets import load_dataset

tasks = load_dataset("<your-org>/<your-dataset>", "tasks", split="test")
# Evaluator only: do not include this configuration in the solver's context.
rubrics = load_dataset("<your-org>/<your-dataset>", "rubrics", split="test")
```

## Run a task

From a local copy of this dataset repository, verify the included files against
`SHA256SUMS` and extract the inputs separately:

```bash
sha256sum -c SHA256SUMS
mkdir -p work/solver-inputs work/evaluation-inputs
tar -xzf solve_norubric.tar.gz -C work/solver-inputs
tar -xzf eval_withrubric.tar.gz -C work/evaluation-inputs
```

The archives use the following layout:

```text
cases/
└── <case_id>/
    ├── user_queries.json
    ├── project/
    │   ├── _attachments/   # when present
    │   ├── _annotations/   # annotation assets
    │   └── ...             # application source
    └── rubric.json         # evaluation archive only
```

For each task, copy `project/` from the solver inputs into an independent
workspace. Give your coding agent the complete request from `user_queries.json`
and access to the task's source and assets. Preserve asset paths referenced by
the request or application. Save the final application under
`submissions/<case_id>/`, with its source, assets, and dependency manifests.

**Keep acceptance criteria outside the solver's context and workspace.** Rubrics
are distributed for reproducible evaluation; load them only after collecting
the candidate application. Retain the original criterion text, order, and counts.

The Co-Design Bench code package provides `cdb prepare`, `cdb judge`, and
`cdb score`. When that package is installed in your evaluation environment,
use these local paths:

```bash
cdb prepare --dataset work/evaluation-inputs --submissions submissions --out work/evaluation
cdb judge --cases work/evaluation/cases.json --out results/run-1 --model opus
cdb score --cases work/evaluation/cases.json --results results/run-1/journal.jsonl --out results/run-1/scores.json
```

The reference judge requires an authenticated Claude CLI, Node.js, Playwright,
and Chromium. Set `--model` to an identifier accepted by your configured CLI.
It supports static frontend applications and npm builds; application builds and
agent tools should run in a disposable evaluation environment. Consult the code
package's evaluation guide for runtime setup and supported applications.

## Evaluation and metrics

The judge-then-refute protocol first gathers source and browser evidence and
assigns each criterion `PASS`, `PARTIAL`, or `FAIL`. A separate verifier
challenges positive credit for stubs, hardcoded outputs, unreachable features,
and mismatches with the requested behavior. Score the final verified verdicts.
Evaluation does not require gold code or target screenshots.

For a task with `n` criteria:

```text
Strict completion = #PASS / n
Graded completion = (#PASS + 0.5 × #PARTIAL) / n
Full task pass    = 1 if all criteria are PASS, otherwise 0
```

Average each metric with **equal weight per task** and report percentages.
PARTIAL earns zero Strict credit and half Graded credit. Report the dataset
scope, model, agent harness, evaluator, and evaluation settings with results.
The public reference judge is a starting point; reproducing the paper's
leaderboard also requires its complete infrastructure and evidence audits.

## Citation

Please cite the [arXiv paper](https://arxiv.org/abs/2610.35138) when using this
dataset. The [project website](https://codesignbench.github.io/) provides the
full evaluation and interactive leaderboard.

```bibtex
@misc{wei2026codesignbench,
  title = {{Co-Design Bench}: Multimodal Collaborative Coding Evaluation for Agentic Models},
  author = {Xilin Wei and Shengyuan Ding and Xinyu Fang and Tiancheng Gu and
            Yuchi Wang and Zhixun Li and Ziyu Liu and Yuhang Zang and
            Weixiang Yu and Cheng Lu and Chonggao Sun and Tong Zhou and
            Dahua Lin and Hang Zhang and Shuai Bai and Dayiheng Liu},
  year = {2026},
  eprint = {2610.35138},
  archivePrefix = {arXiv},
  primaryClass = {cs.AI},
  url = {https://arxiv.org/abs/2610.35138}
}
```