license: mit
language:
- en
pretty_name: foresight-swe-mini
tags:
- benchmark
- coding-agents
- software-engineering
- subset
- foresight-swe
size_categories:
- n<1K
configs:
- config_name: default
data_files:
- split: test
path: data/tasks.jsonl
foresight-swe-mini
14 of the 212 tasks in Foresight-SWE, chosen to match the full benchmark's mix of languages, difficulty and defect types while keeping runs short.
Foresight-SWE asks whether a coding agent avoids a bug nobody told it about. Each task pairs a real pull request that introduced a defect (PR-1) with the later one that fixed it (PR-2). The agent gets only PR-1's task. Resolve rate counts PR-1's tests passing. Foresight resolve rate (FRR) also requires PR-2's held-out tests to pass. See the paper and code.
Read this first. Unlike the other mini benchmarks in this collection, this subset has not been checked against real per-task results, because upstream publishes only totals and per-model breakdowns. The accuracy figures below are simulated.
Changes. The subset started with 15 tasks. Running upstream's gold patches through the upstream harness passed PR-1's tests on 14. The 15th, pandas__49324-49704, cannot be graded: its PR-1 install recipe installs numpy 2 before building pandas, the build fails, and no PR-1 test runs even for the gold patch. It was removed, and every number on this card is for the remaining 14. The gold patches also pass PR-2's held-out tests on 1 of the 14, so a patch identical to upstream's PR-1 would score 1 of 14 on FRR.
What it can tell you
One task is worth 7.1 points, and at leaderboard rates most models would pass 1 to 4 of the 14. Use it to spot large differences, or to compare two setups on the same tasks. Do not use it to rank close models or to estimate a full-benchmark score.
Simulated against the 11 models on the leaderboard:
| tasks | typical FRR error (points) | pairs 5+ points apart in the right order | pairs 10+ points apart in the right order |
|---|---|---|---|
| foresight-swe-mini (14) | 6.9 | 73% | 82% |
| random 10 | 8.6 | 64% | 73% |
| random 14 | 7.0 | 72% | 82% |
| random 20 | 5.9 | 79% | 88% |
| random 30 | 4.7 | 85% | 94% |
| random 60 | 3.1 | 95% | 99% |
| random 100 | 2.0 | 98% | 100% |
The 14 do no better than a random 14 on these numbers. The published task labels explain only 4 to 13% of each model's pass or fail outcomes, so matching on them cannot do much for accuracy. What matching adds is a guaranteed mix and no very slow tasks. A subset chosen from real per-task results might do better; that needs data upstream has not released.
The simulation fits each model to Tables D.1 and D.2 of the paper, then adds a difficulty shared across models and noise per model. Those two additions are assumptions. Numbers are the middle of three runs with different shared-difficulty settings, which changed little.
The mix
| foresight-swe-mini | exact share of 14 | |
|---|---|---|
| Python / JavaScript / TypeScript / Go | 7 / 3 / 2 / 2 | 7.6 / 3.2 / 1.8 / 1.4 |
| PR-1 easy / medium / hard | 2 / 6 / 6 | 3.1 / 5.1 / 5.8 |
| PR-2 easy / medium / hard | 9 / 3 / 2 | 8.3 / 3.4 / 2.3 |
| Major / minor | 9 / 5 | 8.5 / 5.5 |
| Silent / loud | 9 / 5 | 8.5 / 5.5 |
| Bug / feature / mixed | 7 / 6 / 1 | 7.4 / 5.8 / 0.8 |
| Security | 1 | 1.2 |
The 14 cover 10 of the 35 repositories, with at most 3 tasks from any one. Predicted FRR on the subset is within 1.6 points of the published score for all 11 models (data/leaderboard.csv). That only checks the mix, not real results.
How the tasks were chosen
Simulated annealing over the 158 tasks with at most 2,000 regression tests, 100 task tests, 20 held-out tests, a 60 KB patch and 3.5 GB of images. It minimises the difference from the full benchmark in the mix above, in each model's predicted scores and in task size, with a cap per repository. The search picked 15; the broken task was then dropped. python build.py verified.jsonl reproduces the selection, the removal and every number here. Exact task IDs are in data/tasks.jsonl.
Running it
The tasks live upstream; this dataset only tells you which 14 to run. Build a task file:
from datasets import load_dataset
ids = set(load_dataset("LocalLLaMA/foresight-swe-mini", split="test")["instance_id"])
tasks = load_dataset("shaswat123/Foresight-SWE", split="test")
tasks.filter(lambda r: r["instance_id"] in ids).to_json("foresight_mini.jsonl")
Then set DATASET to that file in one of the upstream eval scripts. Each task needs one amd64 Docker image, about 10 GB in total. To compare with the leaderboard, keep the paper's budgets: 250 to 350 steps and $3 per task in mini-swe-agent.
Report resolve rate and FRR, and label results "foresight-swe-mini". Scores on the 14 are not Foresight-SWE scores.
Credit
All tasks and the benchmark design are by Patel, Liao, Henderson, He and Chen.
@misc{patel2026codingagentscatchbugs,
title={Do Coding Agents Catch Their Own Bugs? (They Don't.)},
author={Shaswat Patel and Michel Liao and Peter Henderson and He He and Valerie Chen},
year={2026},
eprint={2611.01181},
archivePrefix={arXiv},
primaryClass={cs.SE},
url={https://arxiv.org/abs/2611.01181},
}