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_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

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

Every task runs on HUD, including the ones that have no Harbor package. 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. The commands follow HUD's documentation. We deployed twenty-two of the folders this way ourselves and synced the task of every folder into the taskset above; we have not run an agent with hud eval from this folder.

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 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, a table that maps each task folder to its instance_id here, the scripted checks, and what was recorded for each task. Every packaged task was run through Harbor on the files in the folder: an empty change scores 0, and the reference fix scores 1.0 with every criterion equal to the task's original grading. The folder contains the reference fixes and the hidden graders, as the rows of this dataset do.

7 more (geode, go-mysql, mongoose, oauth2-proxy, open-xml-sdk, pomerium, rust-postgres) are being packaged or re-checked; they are added as each one passes.

Five tasks have no Harbor package yet: click, sequelize, druid and hooks (one criterion each is judged by a model) and Babylon.js. The folder holds the complete build context of each, and harbor/README.md says for each how it is built and graded and what it needs.

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:

@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.