README.md

---
license: cc-by-4.0
pretty_name: PDL-SWE-Bench
tags:
- benchmark
- evaluation
- code
- software-engineering
- agents
configs:
- config_name: default
  default: true
  data_files:
  - split: test
    path: tasks.parquet
---

# PDL-SWE-Bench

PDL-SWE-Bench is an agentic software-engineering benchmark maintained by
Poindexter Labs — the SWE sibling of
[PDL-Bench](https://huggingface.co/datasets/jrc-poindexterlabs/PDL-Bench).
Each task drops an agent into an original, internally-authored code
repository with an engineering issue written as prose, a passing public test
suite, and a fixed token budget. The agent's submitted patch is graded
against a **held-out acceptance suite** it never saw during the episode.

Like PDL-Bench, this is an **open benchmark** (HLE-style): the complete
answer key ships with the dataset — the reference (gold) patch, the held-out
tests, and the test-level grading contract — so anyone can grade patches
locally and reproduce results. See [Contamination](#contamination).

The row schema follows the **SWE-bench** conventions (`problem_statement`,
`patch`, `test_patch`, `FAIL_TO_PASS`, `PASS_TO_PASS`) so existing tooling
maps over directly, with one difference: these are self-contained synthetic
repositories, shipped inline in the `files` column and as browsable trees
under `tasks/`, rather than references to public GitHub commits. Nothing in
this dataset derives from public repositories or issue trackers.

## Difficulty tiers

18 tasks span five calibrated tiers. Tier placement is gated by
measurement at authoring time, not intuition:

| Tier | Tasks | Bar |
| ---- | ----- | --- |
| T1   | 1     | single-file, local reasoning |
| T2   | 2     | multi-file, requires tracing data flow |
| T3   | 10    | subtle interactions; typically requires constructing a reproduction |
| T4   | 2     | complete fix requires building new machinery across files; certified at authoring (2026-08): GPT-5.4-mini and Claude Haiku 4.5 both scored below 1.0 |
| T5   | 3     | flagship tier; certified at authoring (2026-08): Claude Opus 5, GPT-5.6, and Gemini 3.1 Pro all scored below 1.0 under a 500K-token contract while the reference patch scores 1.0 |

Certification claims are **dated, pre-publication facts**: they were
measured before this dataset was released. Results obtained on these tasks
by models trained after publication carry no such evidentiary weight.

## Reward model

Episodes are graded on a continuous scale rather than binary resolution:

```
reward = 0.80 * hidden_pass_fraction + 0.15 * public_regression + 0.05 * build_health
```

- **1.0** — complete fix; **0.2** — the "do-nothing floor" (public tests
  still pass, build healthy); **between** — genuine partial fixes;
  **below 0.2** — the patch broke working code.
- Hidden suites are built as **graded ladders**: each task shipped with
  author-replayed partial solutions at known reward values, registered
  before any model ran (`graded_ladder_rungs` lists them). In measured
  campaigns, frontier models repeatedly landed exactly on these
  pre-registered values — a landed rung names the specific machinery a
  model failed to build.

## Schema

| Column | Meaning |
| ------ | ------- |
| `instance_id`, `task_id`, `task_version` | task identity |
| `tier`, `domain` | difficulty tier and codebase domain |
| `problem_statement` | the issue text the agent receives |
| `files` | the full starting repository, `list<{path, content}>` |
| `patch` | the reference (gold) solution diff |
| `test_patch` | additive diff placing the held-out tests at `tests/hidden/` |
| `FAIL_TO_PASS` | held-out test IDs: fail at base, pass with `patch` |
| `PASS_TO_PASS` | public test IDs: pass at base, must keep passing |
| `patch_policy_allowed` / `patch_policy_forbidden` | paths the agent may / must not modify (the final workspace state is policed, not just the diff) |
| `token_budget` | the episode's total token contract |
| `hidden_test_count`, `public_test_count` | suite sizes |
| `graded_ladder_rungs` | names of the authored partial-solution rungs |
| `reward_formula` | the grading formula above |

Browsable copies live under `tasks/<task_id>/`: the task `manifest.yaml`,
the fixture tree, the held-out tests (`hidden/`), and the reference patch
(`solution/gold.diff`).

## Evaluating a model

1. Materialize `files` into a working directory (or copy
   `tasks/<task_id>/fixtures/...`).
2. Give the agent `problem_statement`, the repository, and tools; enforce
   `patch_policy_*` and `token_budget`.
3. Apply the agent's patch to a pristine copy; apply `test_patch`; run
   `PASS_TO_PASS` and `FAIL_TO_PASS` (pytest); compute the reward formula.

The numbers published by Poindexter Labs additionally run inside a
network-isolated, container-sandboxed harness with full episode provenance
(model route, prompt version, image digests, trajectories) and calibrated
baselines executed in-campaign (reference patch 1.0, do-nothing agent 0.2,
on every task). Evaluation-as-a-service against the same harness — including
private, uncontaminated task sets — is available; contact Poindexter Labs.

## Contamination

Publishing tasks and answer keys means future training corpora will likely
absorb them; that trade-off is accepted deliberately, as with PDL-Bench.
These tasks were contamination-clean at authoring (original codebases,
original defects, nothing derived from public sources), and all published
certification results predate this release. Poindexter Labs maintains
unpublished task sets under the same methodology for measurement that must
remain contamination-free.

## License

CC-BY-4.0.