Datasets:
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).
Uses
Direct Use
- Evaluating coding agents on realistic repository-level tasks: give the agent
problem_statementand a checkout ofrepoatbase_commitwithsetup_patchapplied, 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 |
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,
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:
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 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.
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.
- Pool. Every task whose current review status on HUD is `verified'. Validation copies of a task are not tasks and were left out.
- 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.
- 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.
- 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.
- 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:
@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.