---
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](https://huggingface.co/datasets/shaswat123/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](https://arxiv.org/abs/2611.01181) and [code](https://github.com/shaswatpatel123/Foresight-SWE).

**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:

```python
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](https://github.com/shaswatpatel123/Foresight-SWE/tree/main/eval). 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.

```bibtex
@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},
}
```