Dataset Card for EnvGap

Leaderboard | Tasks | How runs are scored | Evaluation code

Dataset Summary

EnvGap tests whether an AI coding agent can get a real project to build and run on a clean machine by fixing only its environment: dependency manifests, lockfiles, build and setup files. The source code stays as it is.

The tasks are projects in Python, C++, Java and JavaScript. Each one is a real failure: a dependency that no longer resolves, a system library the build assumes, requirements that cannot coexist, or a package that disappeared from its registry. They come in three sets, which the leaderboard ranks separately:

• Reported: environment failures that users reported in GitHub issues. Some of them no longer happen on a clean machine today. Those stay in as controls, where the right answer is to change nothing and keep the project working.
• Repaired: breakages that the maintainers fixed with a pull request that changed only dependency or build files. Each one fails in a clean container before that fix and passes after it.
• Lite: small projects that AI coding agents (Claude Code, Codex and Gemini Code Assist) wrote from a task description, which did not run on a clean machine as written. Each one fails in a clean container as written and runs once the environment part of the repair made in the study is applied (changed manifests and build files, system packages installed by a setup.sh, sources placed where the build tool expects them), with the source left exactly as the agent wrote it. These projects were never on GitHub, so each task carries its files (project_files).

A task is resolved when the agent's environment installs and the project's command runs. Two more scores come with it: manifest F1 compares the packages the agent declared with the files a system-call trace shows the program actually loading, and safe install is the share of declared packages that exist, are pinned to an exact version and have no known advisory.

Keep the controls in mind when you read a score: an agent that changes nothing gets every control right.

Supported Tasks and Leaderboards

The agent gets the repository at base_commit, the issue text (problem_statement), the error (failure_signature), the ecosystem and the manifest paths. It may run repro_command. It returns new contents for environment files only; a change to any source file is rejected. The evaluation then installs what the agent declared in a fresh container and runs the project.

On the published leaderboard, the score is the agent's first attempt, made before the evaluation has told it anything; the result after up to 5 attempts with the evaluation's output fed back is shown beside it but not ranked. A task only counts if the agent solved it on its own. Where an agent read the project's later history and saw the fix that was eventually merged, the task is scored as unresolved.

Languages

Issue text is mostly English. It was not filtered by language.

Ecosystem	Evaluation image
java	Ubuntu 22.04 with OpenJDK 17 and Maven (envgap-java-eval)
cpp	Ubuntu 22.04 with build-essential, CMake, g++ and pkg-config (envgap-cpp-eval)
python	Ubuntu 22.04 with python3 (3.10), pip and venv (envgap-python-eval)
javascript	Ubuntu 22.04 with Node.js 20 (NodeSource) (envgap-javascript-eval)

Dataset Structure

Data Instances

An example (envgap__Ezibenroc__PyRoaringBitMap-93). Long strings are shortened here and end with ... [N more chars]; the parquet files have the full text.

{
  "instance_id": "envgap__Ezibenroc__PyRoaringBitMap-93",
  "repo": "Ezibenroc/PyRoaringBitMap",
  "base_commit": "89c361ab0961cd3b51249dde4fce95937ec10bdd",
  "project_files": [],
  "patch": "diff --git a/setup.py b/setup.py\n--- a/setup.py\n+++ b/setup.py\n@@ -72,7 +72,7 @@\n     version=VERSION,\n     description='Fast and lightweight set for unsigned 32 bits integers.',\n     long_description=long_description,\n-    setup_requires=['cython'],\n+    setup_requires=['cython<3.0.0'],\n     url='h... [120 more chars]",
  "gold_files": [
    {
      "path": "setup.py",
      "content": "#! /usr/bin/env python3\n\nfrom setuptools import setup\nfrom setuptools.extension import Extension\nfrom distutils.sysconfig import get_config_vars\nimport os\nimport sys\nimport subprocess\nimport platform\n\n\nPKG_DIR = 'pyroaring'\n\nPLATFORM_WINDOWS = (platform.system() == 'Windows')\nPLATFORM_MACOSX = (plat... [2725 more chars]"
    }
  ],
  "problem_statement": "Build error with cython 3\n\nBuilding pyroaring with the cython 3.0.0 results in the following error logs:\r\n\r\n```\r\n$ sh -c -e 'python -P -mbuild --no-isolation --wheel --outdir /buildstream-build/dist .\r\n'\r\n* Getting build dependencies for wheel...\r\n* Building wheel...\r\nrunning bdist_wheel\r\nrunning bu... [10300 more chars]",
  "problem_statement_truncated": false,
  "created_at": "2023-07-24T11:01:01Z",
  "registry_date": "2023-07-30T12:48:33Z",
  "registry_date_source": "pull_request_merged_at",
  "ecosystem": "python",
  "image": "envgap-python-eval",
  "manifest_path": "setup.py",
  "manifest_paths": [
    "setup.py"
  ],
  "bootstrap_command": "python3 -m pip install -q --upgrade pip",
  "resolve_command": "python3 -m pip install .",
  "repro_command": "python3 -m pip install .",
  "run_command": "python3 -c \"\nimport importlib, importlib.metadata as md\nmods = set()\nfor dist in md.distributions():\n    if 'file:///work' not in (dist.read_text('direct_url.json') or ''):\n        continue\n    top = (dist.read_text('top_level.txt') or '').split()\n    if not top:\n        top = [str(f).split('/')[0].... [352 more chars]",
  "d2_command": "python3 -m pip list --format=json > /evidence/D2.raw.json",
  "failure_signature": "error: subprocess-exited-with-error",
  "expected_failure_regex": "error:\\ subprocess\\-exited\\-with\\-error",
  "is_control": false,
  "splits": [
    "full"
  ],
  "source": "repaired",
  "crawl_id": "pr-20260924",
  "issue_url": "https://github.com/Ezibenroc/PyRoaringBitMap/issues/93",
  "issue_number": 93,
  "pull_request": "https://github.com/Ezibenroc/PyRoaringBitMap/pull/95",
  "pr_number": 95,
  "pr_head_commit": "684615af89166275b440d6c2977b0ca0acc71c26",
  "pr_merge_commit": "7e46a671dd28498f647fc885a1b1053aeb267dc5",
  "categories": [
    "misspecification"
  ],
  "security_flags": [],
  "excluded_from_scoring": false,
  "exclusion_reason": null,
  "excluded_since": null,
  "repo_license": "MIT"
}

Data Fields

Do not show the agent patch, gold_files, pull_request, pr_number, pr_head_commit, pr_merge_commit. They contain the answer.

Field	Type	Description
instance_id	string	Task id, envgap__<owner>__<repo>-<issue number>. The number is always the issue number, also for Repaired tasks (their pull request number is in pr_number). To get the repository, read repo rather than parsing the id.
repo	string	GitHub repository, owner/name. Lite tasks were never on GitHub: there it names the agent that wrote the project and the language and study trial, <agent>/<language>-t<trial>.
base_commit	string	The commit the agent starts from and the evaluation rebuilds. Reported tasks: the last default-branch commit at or before the issue was opened. Repaired tasks: the pull request's base commit. Lite tasks: the one commit the harness makes from project_files (fixed author and date, so the hash is always the same).
project_files	list<struct<path: string, content: string>>	Lite tasks only: the project exactly as the coding agent wrote it, one entry per file. The harness writes these files into a fresh repository to start the task. Empty for tasks from GitHub, which start from repo at base_commit.
patch	string	The reference environment fix, as a unified diff against base_commit. It only touches environment files (manifests, lockfiles, build and setup files, Dockerfiles, READMEs), never source or tests; a Lite fix may also add an unchanged copy of one of the project's Java sources under src/main/java, where Maven compiles it. Empty for controls. Do not show it to the agent.
gold_files	list<struct<path: string, content: string>>	The same fix as full file contents, one entry per path (content null means delete). {f['path']: f['content'] for f in row['gold_files']} is exactly the files object of a prediction. Empty for controls. Do not show it to the agent.
problem_statement	string	Issue title, a blank line, then the issue body, exactly as the agents in the published runs saw it.
problem_statement_truncated	bool	True when the issue body was already cut at 3,000 characters when it was collected. It ships as agents saw it.
created_at	string	When the issue was opened (ISO 8601). For Lite tasks, when the agent wrote the project, which is also the date of the commit base_commit names.
registry_date	string	Package registries are limited to what was published by this time: PyPI through a date-filtered index, npm through npm_config_before. Maven and system packages are not date-limited.
registry_date_source	string	Where registry_date comes from: pull_request_merged_at (Repaired), issue_created_at (Reported) or repaired_at (Lite: when the project's repair was saved).
ecosystem	string	python, cpp, java or javascript. Picks the evaluation image and how installed packages are listed.
image	string	Local Docker tag of the evaluation image, built with envgap build-images. Not pushed to any registry.
manifest_path	string	The main dependency manifest (setup.py, CMakeLists.txt, pom.xml, package.json, ...).
manifest_paths	list<string>	Every manifest read to get the declared dependencies.
bootstrap_command	string	First evaluation step: sets up the toolchain.
resolve_command	string	Installs or builds the declared environment. Must exit 0 for the task to count as resolved.
repro_command	string	Reproduces the failure: it fails at base_commit on repair tasks and passes after the reference fix. Agents may run it.
run_command	string	The workload that is run under a system-call trace. Resolved means resolve_command and this both exit 0.
d2_command	string	Command that lists installed packages, when the ecosystem default does not work. Usually null.
failure_signature	string	The line of the failing output that identifies the problem. Empty for controls.
expected_failure_regex	string	Pattern the evaluation looks for in the failing output. For controls it is the failure from the report that no longer happens; for a few of them it was taken from the issue text rather than from real build output.
is_control	bool	True when the environment already works at base_commit. The right move is to change nothing and not break it.
splits	list<string>	Split labels the harness stores (full, lite, secure). The Hub configs are built from these and from source.
source	string	reported (a failure users reported in an issue), repaired (a breakage maintainers fixed with an environment-only pull request) or lite (a project a coding agent wrote whose environment did not work on a clean machine).
crawl_id	string	Internal id of the collection run a Repaired task came from; null for Reported and Lite tasks.
issue_url	string	The GitHub issue; null for Lite tasks.
issue_number	int64	The GitHub issue number; for Lite tasks, the number of the task the agent was given.
pull_request	string	The merged pull request whose environment changes are the reference fix (Repaired only). Do not show it to the agent.
pr_number	int64	Pull request number (Repaired only).
pr_head_commit	string	Head commit of that pull request. gold_files match its contents exactly.
pr_merge_commit	string	Merge commit of that pull request.
categories	list<string>	Failure types (misspecification, underspecification, conflict, security). A task can have several or none. Assigned by rules and checked by an AI assistant.
security_flags	list<string>	Registry audit findings that put a task in secure.
excluded_from_scoring	bool	True for tasks found to be broken after they were admitted. They stay in the data so you can see them, but every leaderboard leaves them out. Filter on this before scoring.
exclusion_reason	string	Why the task is excluded; null when it is scored.
excluded_since	string	When it was excluded (ISO 8601 UTC); null when scored.
repo_license	string	SPDX license id of the repository (null if GitHub reported none). The issue text, patch and gold_files come from that repository and fall under this license. Null for Lite tasks, whose projects were written by coding agents in a study that distributes them for research replication without a license of their own.

Nothing is checked with unit tests. repro_command and run_command decide the result: success is an exit code plus the trace. Agents never see issue comments.

Data Splits

Every config has one test split. There is no training data; please do not train on it.

full is every task. reported, repaired and lite are the three leaderboard boards. secure holds tasks where the failure or its fix involves a risky package (removed, nonexistent, vulnerable or unpinned). candidates is not a task set: it lists every candidate we looked at, described below.

A few tasks turned out to be broken after they were admitted. They are still in the data, marked with excluded_from_scoring, and every leaderboard leaves them out:

Task	Set	Kind	Reason
envgap__CGAL__cgal-8981	repaired	repair	Passed with no change at all on the 2026-09-29 recheck, so doing nothing would count as a fix.
envgap__Lancetnik__Propan-87	reported	repair	The reference fix no longer made the project run on the 2026-09-29 recheck.
envgap__VowpalWabbit__vowpal_wabbit-2678	repaired	repair	Passed with no change at all on the 2026-09-29 recheck, so doing nothing would count as a fix.
envgap__adrienverge__yamllint-387	repaired	repair	Passes with no change at all in the evaluation container, so doing nothing would count as a fix.
envgap__chainer__chainer-679	reported	control	setup.py builds its dependency list at run time, so the declared dependencies cannot be read.
envgap__gabime__spdlog-3081	reported	control	The CMake parser misread a bracket inside a quoted string, so no run could be measured.
envgap__ggml-org__llama.cpp-27834	repaired	repair	Passed with no change at all on the 2026-09-29 recheck, so doing nothing would count as a fix.
envgap__keycloak__keycloak-51785	repaired	repair	The maintainers' fix no longer made the project run on the 2026-09-29 recheck.
envgap__kubernetes-client__java-1615	repaired	repair	Passed with no change at all on the 2026-09-29 recheck, so doing nothing would count as a fix.
envgap__npm__cli-2818	reported	control	The repository commits its node_modules folder, so any install changed tracked files and every attempt was rejected.
envgap__terricain__aioboto3-242	repaired	repair	The maintainers' fix no longer made the project run on the 2026-09-29 recheck.
envgap__txoof__PaperPi-120	reported	repair	The recipe pointed at the wrong requirements file, so the failure it reproduced was not the reported one.

from datasets import load_dataset

ds = load_dataset("bhanuprakashvangala/EnvGap", "full", split="test")       # all tasks
ds = ds.filter(lambda r: not r["excluded_from_scoring"])
repaired = load_dataset("bhanuprakashvangala/EnvGap", "repaired", split="test")

The candidates config

Most of what we looked at did not become a task. The candidates config is the default one the dataset viewer opens on. It lists every candidate, the same list as the Tasks page on the website. set says where a candidate came from: reported for a GitHub issue, repaired for a merged pull request and lite for a project a coding agent wrote. outcome says what happened to it:

• task: it became a benchmark task.
• verified: the failure reproduces in a clean container and the known fix makes the project run, but it has not been scored yet.
• already_works: the project already builds and runs before the fix, so there is nothing to repair.
• not_reproduced: in a clean container the failure did not show up, or the known fix did not make the project run.
• code_fix: a project a coding agent wrote whose repair changed source code, so it is not an environment task.
• fix_not_recorded: a project a coding agent wrote that was made to work, but its repair cannot be rebuilt from the saved files (the saved copy shows no change, or not all of the changes the study's notes describe).
• not_fixed: a project a coding agent wrote that was never made to work.
• not_checked: it has no verdict yet and is waiting for its clean-container check.

Only rows with outcome == "task" can be scored, and they are exactly the rows of full (filter on excluded_from_scoring there before scoring). The other rows have no commands or failure patterns, so they are there for browsing and for studying what gets filtered out, not for evaluation. Where it is filled in, patch is the reference fix for tasks, and the pull request's own environment changes for the other pull requests where the crawl recorded the files. Like the task patch, keep it away from an agent. For the lite set, every project of the coding-agent study's main run is listed (each agent once per task and language), including the ones that worked first time or needed a code change, together with the projects from its extra runs whose repair had an environment part: project_files holds each project exactly as the agent wrote it, generated_by names the agent and domain the kind of program.

from datasets import load_dataset

candidates = load_dataset("bhanuprakashvangala/EnvGap", "candidates", split="test")
tasks = candidates.filter(lambda r: r["outcome"] == "task")

Dataset Creation

Curation Rationale

Many real breakages come from the environment, not the code: the code is fine, and the declared environment is wrong, incomplete or contradictory. EnvGap collects such breakages where the fix changes only environment files, and checks each one with a command run in a clean container with the package registry set back to the date of the failure.

Source Data

Reported. Each task started from a GitHub issue about an environment failure. It was admitted only after the failure was reproduced in a clean container at the commit from the day the issue was opened, and a reference fix made it pass. Issues that no longer fail became controls.

Repaired. We searched the repositories of widely used packages for merged pull requests that were linked to an issue and changed only environment files. Each one that matched GitHub exactly (issue, pull request and changed files) was run in a clean container, and it became a task only if it failed before the fix and passed after it.

Lite. Three coding agents (Claude Code, Codex and Gemini Code Assist) were each given the same set of small programming tasks in all four languages and asked for a complete project with a dependency manifest for a clean Ubuntu machine. Every project was run in a clean container. When it failed, the error went back to the agent until the project worked, and both the project as written and the repaired project were kept. A project became a task only if the environment part of its repair is enough: in a clean container it fails as written and runs once that part is applied, with the source exactly as the agent wrote it. Source edits the repair also made are left out, and system packages it installed become a setup.sh.

Annotations

No task was reviewed by a person. The commands, failure patterns and (for Reported repairs) the reference fixes were written by AI tools; every task was then checked in a clean container. For Repaired tasks the reference fix is the maintainers' own change.

How it was made	Details
AI assistant	An AI coding assistant (Codex) wrote the commands and the reference fix from the issue, the source and the failing logs. The fix was then checked in a clean container.
model	A model wrote the reference fix, which was then checked in a clean container. Not reviewed by a person.
recipe generator	A control whose commands came from the default recipe generator. It was admitted because the unchanged environment passed in a clean container.
maintainer fix	The reference fix is the maintainers' own merged pull request. Commands were generated, and the task fails before that fix and passes after it in a clean container.
coding-agent study	The reference fix is the environment part of the repair the coding agent made in the study (system packages installed by a setup.sh, the source left as written); the program runs with the command the study traced. The task fails before that fix and passes after it in a clean container.

Some tasks carry a failure type (misspecification, underspecification, conflict or security). These are assigned by rules and checked by an AI assistant.

Personal and Sensitive Information

Issue text may contain GitHub usernames, as it does on GitHub. Pull request authors are not included. All text was scanned for credentials before export; the only hits were text that looks like a token but is not one, left as it is (ghp_import in envgap__PyCQA__isort-2077, an example Authorization header in envgap__claude-code__cpp-t1-24, PEM key markers as string literals in code in envgap__claude-code__cpp-t3-12, an example Authorization header in envgap__claude-code__java-t1-24, an example Authorization header in envgap__claude-code__java-t2-24, an example Authorization header in envgap__claude-code__java-t2-27, an example Authorization header in envgap__claude-code__java-t3-27). In the projects coding agents wrote, the scan also matched PEM key markers as string literals in code and an example Authorization header; none of them is a real credential, and they are left as written.

Evaluation

The evaluation code for this exact task set is in harness/envgap-source.zip in this repository. Unzip it, run pip install -e ., then envgap build-images (Linux, Docker, linux/amd64, with ptrace allowed). The harness scores against its own copy of the tasks; envgap hf check --release harness/envgap-source.zip confirms that copy has corpus id 5debed7bf026.

Predictions are JSON Lines, one line per task: {"instance_id", "files": {path: new content or null}, "trajectory": [...], "cost_usd"}. Include every task of the split, excluded ones too; the report drops them.

envgap eval --pred predictions.jsonl --split reported --out results/my-agent-reported
envgap eval --pred predictions.jsonl --split repaired --out results/my-agent-repaired
envgap report results/my-agent-reported results/my-agent-repaired

envgap eval gives each prediction one attempt with no feedback. The leaderboard runs were agent runs instead: envgap run --agent bedrock --model <model> --split reported|repaired --k 1 --max-attempts 5. Each task gets up to 5 attempts (the harness default is 10), the evaluation output of a failed attempt goes back to the agent, and each attempt has 20 minutes. The leaderboard's ranking uses the first attempt only, which is what a run with a single allowed attempt measures. Say which setting you used when you report a number.

Later history. The harness gives the agent a checkout that stops at base_commit, so the fix cannot be read from git. A plain git clone of repo does include the fix. If you build your own agent setup, fetch only the base commit (Lite rows are not on GitHub: write project_files into an empty repository instead, which the harness does with a fixed author and date so the commit matches base_commit):

git init work && git -C work fetch --depth=1 https://github.com/<repo>.git <base_commit> && git -C work checkout --detach FETCH_HEAD

To check the reference fixes (controls get files: {}):

import json
from datasets import load_dataset
with open("gold.jsonl", "w", encoding="utf-8") as out:
    for r in load_dataset("bhanuprakashvangala/EnvGap", "full", split="test"):
        files = {g["path"]: g["content"] for g in r["gold_files"]}
        out.write(json.dumps({"instance_id": r["instance_id"], "files": files, "trajectory": [{"note": "gold"}]}) + "\n")

Licensing Information

The EnvGap metadata (commands, patterns, labels and the other columns) is released under MIT. The issue text, patch and gold_files come from the listed projects and stay under each project's own license, given per row in repo_license. The Lite projects were written by coding agents in a research study that distributes them for research replication without a license of their own, so their repo_license is null; the task text the agents were given comes from that study's prompts (CC BY 4.0). See LICENSE.md.

Contact

Questions, bug reports and broken tasks: please open a thread on the discussion page.