---
# Dataset card metadata. Spec: https://github.com/huggingface/hub-docs/blob/main/datasetcard.md?plain=1
pretty_name: EC SWE
language:
- en
language_details: en-US
license: other
license_name: mixed-upstream
license_link: LICENSE
license_details: >-
  Each task carries code from an open-source upstream repository (patch,
  test_patch, grader_files, dockerfile), under that repository's licence; the
  repo_license column names it per row. The task text and grader design are
  copyright 2026 Toptal, LLC; contact Toptal, LLC for licence terms.
tags:
- code
- software-engineering
- swe-bench
- agents
- coding-agents
- benchmark
- evaluation
- bug-fixing
- program-repair
- multi-language
annotations_creators:
- expert-generated
language_creators:
- expert-generated
multilinguality:
- monolingual
size_categories:
- n<1K
source_datasets:
- original
task_categories:
- text-generation
task_ids:
- language-modeling
configs:
- config_name: default
  data_files:
  - split: test
    path: data/test.parquet
dataset_info:
  config_name: default
  features:
  - name: instance_id
    dtype: string
  - name: repo
    dtype: string
  - name: base_commit
    dtype: string
  - name: setup_patch
    dtype: string
  - name: problem_statement
    dtype: string
  - name: patch
    dtype: string
  - name: test_patch
    dtype: string
  - name: patch_files
    list: string
  - name: grader
    list:
    - name: criterion
      dtype: string
    - name: weight
      dtype: float64
  - name: grader_files
    list:
    - name: path
      dtype: string
    - name: encoding
      dtype: string
    - name: content
      dtype: string
  - name: dockerfile
    dtype: string
  - name: language
    dtype: string
  - name: repo_license
    dtype: string
  - name: hud_task
    dtype: string
  - name: difficulty
    dtype: string
  - name: agent_runs
    dtype: int64
  - name: agent_rewards
    list: float64
  - name: agent_mean_reward
    dtype: float64
  - name: agent_solve_rate
    dtype: float64
  - name: agent_models
    list: string
  - name: gold_reward
    dtype: float64
  - name: base_reward
    dtype: float64
  splits:
  - name: test
    num_bytes: 16940905
    num_examples: 24
  download_size: 7702204
  dataset_size: 16940905
---

# Dataset Card for ExpertCrowd SWE (EC-SWE)

This dataset contains real software engineering tasks for evaluating coding
agents. Each one is a bug or missing behaviour in a real open-source repository, pinned to a
commit, with a written problem statement, a reference fix, and a weighted
grader backed by hidden tests. The tasks were chosen to sit at the typical
difficulty of the pool of reviewed tasks they were drawn from, measured by how
well current frontier agents scored on them. Mean agent reward runs from
0.17 to 0.47, and 3.1% of agent runs scored a full 1.0.

## Dataset Details

### Dataset Description

Every task was written by a software engineer, run on the HUD evaluation
platform, and accepted by a human reviewer (review status `verified`). Before a
task can be accepted, its reference fix has to score 1.0 on every grader
criterion, the unchanged repository has to fail, and at least 5 agent runs on a
current frontier model have to be graded. Automated checks also look at the
prompt (it must state the symptom, not the fix), the grader (weights add up to
100, each criterion is one observable requirement), and whether the task
overlaps a public benchmark.

This dataset keeps the tasks closest to the typical difficulty of all verified tasks with agent scores, chosen from those that met every export
check (see [Curation Rationale](#curation-rationale)).

## Uses

### Direct Use

- Evaluating coding agents on realistic repository-level tasks: give the agent
  `problem_statement` and a checkout of `repo` at `base_commit` with
  `setup_patch` applied, then score the resulting diff with the task's grader.
- Studying difficulty: every task carries the per-run rewards of graded
  agent runs, so results can be compared against a known baseline.
- Building or validating graders and task-quality tooling, using the reference
  fix, the hidden tests and the weighted criteria together.

## Dataset Structure

One split, `test`, with one row per task.

| Field | Type | What it holds |
| --- | --- | --- |
| `instance_id` | string | `<owner>__<repo>-<task>`, unique |
| `repo` | string | upstream GitHub repository, `owner/name` |
| `base_commit` | string | the 40-character upstream commit the task is built on |
| `setup_patch` | string | a patch the environment applies to `base_commit` before the agent starts; empty for most tasks. Apply it first: `patch` and `test_patch` are written against the result |
| `problem_statement` | string | the exact prompt the agent was sent, including a short preamble about the workspace (`/workspace/repo`) and resource limits |
| `patch` | string | the reference fix, non-test files only |
| `test_patch` | string | test files the reference fix adds or changes (may be empty) |
| `patch_files` | list of string | every file the reference fix touches |
| `grader` | list of (criterion, weight) | the grader's criteria and their weights in percent; weights add up to 100 |
| `grader_files` | list of (path, encoding, content) | the grader as built into the task environment (`grader/`, `grading/` or `protected/`): hidden tests, the repository's regression suite where the grader reruns it, and the script that scores a run. `encoding` is `utf-8`, or `base64` for binary fixtures. The author's calibration notes, control diffs and adversarial manifests are left out |
| `dockerfile` | string | the environment the agent ran in |
| `language`, `repo_license` | string | from the GitHub API for `repo` |
| `hud_task` | string | the task's name on HUD, for tracing a row back |
| `difficulty` | string | bucket of `agent_mean_reward`: very hard (under 0.2), hard, medium, easy, very easy (0.8 and up) |
| `agent_runs`, `agent_rewards` | int, list of float | graded agent runs on current models and each run's reward (0 to 1) |
| `agent_mean_reward`, `agent_solve_rate` | float | mean reward, and the share of runs that scored a full 1.0 |
| `agent_models` | list of string | the models those runs used |
| `gold_reward`, `base_reward` | float | reward of the reference fix (1.0) and of the unchanged repository |

```python
from datasets import load_dataset

ds = load_dataset("ExpertCrowd/ec-swe", split="test")
hard = ds.filter(lambda r: r["difficulty"] in ("very hard", "hard"))
```

### At a glance

- **Tasks:** one per repository
- **Models those runs used:** claude-fable-5, claude-fable-5-1, claude-opus-5, gpt-6-astra

| Language | Tasks |
| --- | --- |
| Python | 6 |
| Go | 6 |
| TypeScript | 5 |
| Java | 3 |
| JavaScript | 2 |
| Rust | 1 |
| C# | 1 |

### Difficulty

Difficulty is the mean reward of graded agent runs on current frontier models.
The tasks sit around the middle of the distribution of every verified task with
5 or more graded agent runs, so the mean and median stay close to the pool's.
The easy tail is left out, and one task comes from the very hard end:

| Mean agent reward | Difficulty | All verified with agent scores | This dataset |
| --- | --- | --- | --- |
| 0.0 to 0.2 | very hard | (4%) | 4% |
| 0.2 to 0.4 | hard | (49%) | 46% |
| 0.4 to 0.6 | medium | (44%) | 50% |
| 0.6 to 0.8 | easy | (2%) | 0% |
| 0.8 to 1.0 | very easy | 0 (0%) | 0% |
| **mean** | | **0.377** | **0.383** |
| **median** | | **0.379** | **0.395** |

### Tasks

| Instance | Repository | Language | Difficulty | Mean reward |
| --- | --- | --- | --- | --- |
| `oauth2-proxy__oauth2-proxy-proxy_cookie_accounting` | oauth2-proxy/oauth2-proxy | Go | very hard | 0.17 |
| `bashrc2__epicyon-epicyon_deleted_post_announce_cache_contract-1c066303` | bashrc2/epicyon | Python | hard | 0.34 |
| `apache__geode-geode_oql_index_null_semantics_contract-1c066303` | apache/geode | Java | hard | 0.34 |
| `sequelize__sequelize-sequelize-bulkcreate-ignore-duplicates` | sequelize/sequelize | TypeScript | hard | 0.34 |
| `alibaba__druid-druid_lenient_script` | alibaba/druid | Java | hard | 0.35 |
| `python-rope__rope-rope_rename_all_reexport_owners_contract-1c066303` | python-rope/rope | Python | hard | 0.35 |
| `igniterealtime__Openfire-openfire_userdeleting_last_owner_contract-0163de9c` | igniterealtime/Openfire | Java | hard | 0.36 |
| `Zettlr__Zettlr-zettlr_clickable_keywords` | Zettlr/Zettlr | TypeScript | hard | 0.36 |
| `buchgr__bazel-remote-bazel_remote_disk_eviction_accounting_contract-afe5ea56` | buchgr/bazel-remote | Go | hard | 0.37 |
| `terser__terser-retained_top_level_names_keep_their_values` | terser/terser | JavaScript | hard | 0.38 |
| `ory__kratos-kratos_cleanup_stale_flows_courier_contract` | ory/kratos | Go | hard | 0.38 |
| `dotnet__Open-XML-SDK-open_xml_sdk_deletepart_refs_contract-1c066303` | dotnet/Open-XML-SDK | C# | hard | 0.39 |
| `dgraph-io__badger-journal_recovery_after_unclean_stop` | dgraph-io/badger | Go | medium | 0.40 |
| `pomerium__pomerium-pomerium_route_order_contract` | pomerium/pomerium | Go | medium | 0.40 |
| `BabylonJS__Babylon.js-babylonjs_scene_remove_owner_refs_contract-382616f8` | BabylonJS/Babylon.js | TypeScript | medium | 0.40 |
| `alibaba__hooks-ahooks_request_cache_races` | alibaba/hooks | TypeScript | medium | 0.41 |
| `go-mysql-org__go-mysql-go_mysql_mariadb_compressed_columns` | go-mysql-org/go-mysql | Go | medium | 0.41 |
| `sfackler__rust-postgres-shared_handle_abandoned_operations` | sfackler/rust-postgres | Rust | medium | 0.42 |
| `celery__celery-celery_retry_expires_countdown_contract` | celery/celery | Python | medium | 0.43 |
| `colinhacks__zod-zod-json-schema-target-legality` | colinhacks/zod | TypeScript | medium | 0.43 |
| `pallets__click-click-help-defaults` | pallets/click | Python | medium | 0.43 |
| `tsileo__microblog.pub-microblogpub_deleted_object_resurrect_lookup_contract-382616f8` | tsileo/microblog.pub | Python | medium | 0.43 |
| `jelmer__xandikos-xandikos_itip_recurrence_id_override_contract-c6aa163a` | jelmer/xandikos | Python | medium | 0.46 |
| `Automattic__mongoose-mongoose_syncindexes_contract-97c2a76f` | Automattic/mongoose | JavaScript | medium | 0.47 |

## Running the tasks

There are two ways to run a task: on HUD, the platform the tasks were written for, or with
Harbor on your own machine.

### On HUD

The tasks are published there as the taskset [`ec-swe`](https://www.hud.ai/shared/tasksets/979e6e02-d726-46f6-a066-914afc5c9f44),
which anyone can view; it holds all 24.

To run a task in a HUD workspace of your own: each folder under `harbor/sources/` is the build
source of one task's HUD environment. With a HUD account, on Linux, macOS or WSL:

```bash
pip install hud                       # the hud command
hud set HUD_API_KEY=<your key>        # a key from hud.ai/project/api-keys
hf download ExpertCrowd/ec-swe --repo-type dataset --include "harbor/sources/**" --local-dir ec-swe
cd ec-swe/harbor/sources/<task folder>
hud deploy                            # builds the environment in your HUD workspace
hud sync tasks my-ec-swe tasks.py     # puts this folder's task into a taskset of yours
hud eval my-ec-swe claude --full      # runs it on the platform with an agent
```

Results appear as jobs and traces on hud.ai (`hud jobs`). On HUD the agent and the grader
share one container, kept apart by file permissions, and the four tasks with a criterion
judged by a model get that judge from HUD's gateway. Outside HUD, that judge can
run on your own key at any OpenAI-compatible endpoint, such as OpenRouter; `harbor/README.md`
says how. The commands follow HUD's documentation.

### With Harbor

The `harbor/` folder of this repository makes tasks runnable end
to end with [Harbor](https://github.com/harbor-framework/harbor) 0.23.0 and
Docker, and nothing else. Each task under `harbor/tasks/` is packaged as two containers: one for the
agent, holding the repository at its base commit and nothing from the grading
side, and a separate one that grades the patch the agent leaves behind with the
task's original grader. Both are offline by default. The folder holds each
task's complete build context, so its environment can be rebuilt from this
repository alone.

```bash
hf download ExpertCrowd/ec-swe --repo-type dataset --include "harbor/**" --local-dir ec-swe
cd ec-swe/harbor
pip install harbor==0.23.0
python build_images.py --task <task folder>
harbor run -p tasks/<task folder> -a oracle     # the reference fix: reward 1.0
harbor run -p tasks/<task folder> -a nop        # no change: reward 0.0
harbor run -p tasks/<task folder> -a <agent> -m <model> --allow-agent-host <model API host>
```

`harbor/README.md` has the requirements and a table that maps each task folder to
its `instance_id` here. The folder contains the reference fixes
and the hidden graders, as the rows of this dataset do.

## Dataset Creation

### Curation Rationale

The goal was a public set at the typical difficulty of the full pool: hard
enough that no current agent solves the tasks reliably, without tasks so hard
that every agent scores near zero, or so easy that they no longer separate
models.

1. **Pool.** Every task whose current review status on HUD is `verified'. Validation copies of a task are not tasks and were
   left out.
2. **Export checks.** A task was kept only if HUD gave a prompt, a GitHub
   repository and a pinned 40-character commit, a non-empty reference fix,
   grader weights adding up to 100, a reference run on the current task version
   scoring 1.0, and at least 5 graded agent runs on a current model. The
   repository had to be an established upstream project, not one created for
   the task, and the environment could not depend on a task author's personal
   images. Two tasks with the same reference fix, or the same repository and
   scenario, count once.
3. **Stratified sample.** All verified tasks with 5 or more
   graded agent runs were ranked by mean agent reward and cut into bins of
   equal size. Each bin contributed one task that passed the export checks,
   preferring a repository not yet in the sample. Matching against the whole
   scored pool, not only the exportable part, keeps the export checks from
   skewing the difficulty curve.
4. **Typical difficulty.** From that sample, the tasks whose mean agent
   reward was closest to the sample mean (0.374) were kept: every task within
   0.059 of it. The nearest task left out was 0.064 away, so the cut does not
   split a tie.
5. **Replacement.** Six tasks of that selection were later replaced by six
   other verified tasks from the same pool. The replacements were picked by
   their average score across six current models, not by the rule in step 4,
   so three of them lie outside its band (mean agent reward 0.17, 0.46
   and 0.47).

### Source Data

#### Data Collection and Processing

Task authors chose a bug or missing behaviour in an open-source repository,
wrote the problem statement, built a container that checks out the repository at
a pinned commit, wrote a reference fix and a hidden-test grader, and ran the
task on HUD: a reference run, a run with no fix, and at least 5 agent runs. The
export reads the prompt from the agent's own trace, the criteria and weights
from the reference run's grading, and the repository, commit, reference fix and
grader from the environment build.

#### Who are the source data producers?

The code comes from the upstream open-source projects named in `repo`, written
by their contributors. The problem statements, reference fixes, hidden tests and
graders were written by professional software engineers contracted to build the
tasks.

### Annotations

#### Annotation process

Each task was reviewed on HUD by a human reviewer, who could send it back for
revision or reject it; only tasks marked `verified` are included. Automated
checks run before review on the prompt, the grader, the reference and baseline
runs, and overlap with public benchmarks. The difficulty fields come from graded
agent runs, not from people.

#### Who are the annotators?

Experienced software engineers acting as reviewers, separate from each task's
author.

#### Personal and Sensitive Information

The tasks are about source code. Author and reviewer names were left out of
the export. Upstream code can contain contributor names in comments, licence
headers or commit metadata, as it does in the upstream repositories.

## Recommendations

Report `agent_solve_rate`-style full solves alongside mean reward, report
results per difficulty bucket as well as overall, and give the model's training
cutoff relative to this dataset's release.

## Citation

**BibTeX:**

```bibtex
@misc{toptal2026ecswe,
  author       = {{Toptal, LLC}},
  title        = {{EC SWE}},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/ExpertCrowd/ec-swe}}
}
```

**APA:**

Toptal, LLC. (2026). *EC SWE* [Data set]. Hugging Face.
https://huggingface.co/datasets/ExpertCrowd/ec-swe

## Glossary

- **Gold run:** the task run with the reference fix applied. It must score 1.0.
- **Base run:** the task run on the unchanged repository. It should score low.
- **Reward:** the grader's weighted score for one run, 0 to 1.
- **Verified:** a task a human reviewer accepted on HUD.

## Dataset Card Authors

Toptal, LLC

## Dataset Card Contact

Toptal, LLC, through the ExpertCrowd organization on Hugging Face.