task_id string | instruction string | author_name string | author_email string | difficulty string | category string | tags list | parser_name string | max_agent_timeout_sec float64 | max_test_timeout_sec float64 | expert_time_estimate_min int64 | junior_time_estimate_min int64 | task_yaml string | task_toml string | dockerfile string | solution string | tests dict | dockerless dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
tbdl-access-log-report | # Access log report
`logs/access.log` is a web server access log in a combined-ish format:
```
<ip> - - [<timestamp>] "<METHOD> <path> HTTP/1.1" <status> <bytes> "<referer>" "<user-agent>" <duration_ms>
```
Some lines are damaged. The user-agent field may contain escaped double quotes
(`\"`), so the line cannot be p... | WorkBuddy Benchmarks | benchmarks@example.invalid | medium | data-processing | [
"log-parsing",
"text-processing",
"json",
"python"
] | pytest | 600 | 120 | 25 | 90 | # Terminal-Bench task definition
instruction: |
# Access log report
`logs/access.log` is a web server access log in a combined-ish format:
```
<ip> - - [<timestamp>] "<METHOD> <path> HTTP/1.1" <status> <bytes> "<referer>" "<user-agent>" <duration_ms>
```
Some lines are damaged. The user-agent field may c... | schema_version = "1.4"
source = "TerminalBench-DockerLess"
[task]
name = "swedl/access-log-report"
authors = [{ name = "WorkBuddy Benchmarks", email = "benchmarks@example.invalid" }]
description = "Aggregate a damaged access log into a canonical JSON report, a malformed-line index and a gzip archive."
keywords = ["log... | FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
bash coreutils gzip git \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /workspace
COPY logs/ /workspace/logs/
CMD ["/bin/bash"]
| #!/usr/bin/env bash
# Oracle solution: a regex-based parser that survives escaped quotes in the
# user-agent field, plus deterministic JSON/gzip output.
set -euo pipefail
cd "$TB_WORK"
mkdir -p tools
cat > tools/report.py <<'PYEOF'
import gzip
import json
import math
import re
from collections import Counter
from path... | {
"test.sh": "#!/usr/bin/env bash\n# Verifier entrypoint. Runs the pytest suite and lets its exit code stand as the\n# reward signal (0 = solved).\nset -uo pipefail\ncd \"$TB_ROOT/tests\"\npython -m pytest -v --tb=short -p no:cacheprovider test_outputs.py\n",
"test_outputs.py": "import gzip\nimport json\nimport os\... | {
"setup": "",
"setup_timeout_sec": 120,
"files": {
"logs/access.log": "10.0.0.1 - - [10/Oct/2026:13:00:00 +0000] \"GET /index.html HTTP/1.1\" 200 200 \"-\" \"curl/8.5.0\" 3\n10.0.0.2 - - [10/Oct/2026:13:00:17 +0000] \"GET /index.html HTTP/1.1\" 200 213 \"https://example.com/\" \"curl/8.5.0\" 25\n10.0.0.3 - -... |
tbdl-git-recovery | # Recover a broken release repository
The git repository in the workspace was left in a mess after a bad afternoon.
`main` currently has five commits, but the module `src/app.py` was deleted by the
`Drop legacy module` commit and nobody kept a copy. An experiment that was never
merged lives on as an unreachable commit... | WorkBuddy Benchmarks | benchmarks@example.invalid | hard | software-engineering | [
"git",
"forensics",
"history-recovery"
] | pytest | 600 | 120 | 20 | 75 | # Terminal-Bench task definition
instruction: |
# Recover a broken release repository
The git repository in the workspace was left in a mess after a bad afternoon.
`main` currently has five commits, but the module `src/app.py` was deleted by the
`Drop legacy module` commit and nobody kept a copy. An experiment... | schema_version = "1.4"
source = "TerminalBench-DockerLess"
[task]
name = "swedl/git-recovery"
authors = [{ name = "WorkBuddy Benchmarks", email = "benchmarks@example.invalid" }]
description = "Restore a deleted module from history, resurrect an unreachable commit, tag a release and leave a clean tree."
keywords = ["gi... | FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
bash coreutils git \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /workspace
COPY setup.sh /tmp/setup.sh
RUN bash /tmp/setup.sh
CMD ["/bin/bash"]
| #!/usr/bin/env bash
# Oracle solution: find the lost commit through fsck, recover the file from the
# right historical revision, tag, ignore and commit.
set -euo pipefail
cd "$TB_WORK"
git config user.name "Release Bot"
git config user.email "release@example.invalid"
# 1. restore src/app.py from "Add config loader"
l... | {
"test.sh": "#!/usr/bin/env bash\n# Verifier entrypoint. Runs the pytest suite and lets its exit code stand as the\n# reward signal (0 = solved).\nset -uo pipefail\ncd \"$TB_ROOT/tests\"\npython -m pytest -v --tb=short -p no:cacheprovider test_outputs.py\n",
"test_outputs.py": "import os\nimport subprocess\nfrom p... | {
"setup": "#!/usr/bin/env bash\n# Builds the broken repository state. This is the Dockerfile's analogue: it\n# constructs the environment the agent wakes up in, deterministically.\nset -euo pipefail\ncd \"$TB_WORK\"\n\ngit init -q -b main\ngit config user.name \"Release Bot\"\ngit config user.email \"release@example... |
tbdl-csv-canon | # `canon` — canonicalise a CSV export
Downstream tools need one boring, byte-stable TSV. Write an executable script at
`bin/canon` (shebang, `chmod +x`) that is invoked as:
```
./bin/canon <input.csv> <output.tsv>
```
## Input
UTF-8 CSV, possibly with a byte-order mark, possibly CRLF, RFC 4180 quoting:
fields may b... | WorkBuddy Benchmarks | benchmarks@example.invalid | hard | data-processing | [
"csv",
"cli",
"spec-compliance",
"exit-codes"
] | pytest | 900 | 120 | 35 | 120 | # Terminal-Bench task definition
instruction: |
# `canon` — canonicalise a CSV export
Downstream tools need one boring, byte-stable TSV. Write an executable script at
`bin/canon` (shebang, `chmod +x`) that is invoked as:
```
./bin/canon <input.csv> <output.tsv>
```
## Input
UTF-8 CSV, possibly with ... | schema_version = "1.4"
source = "TerminalBench-DockerLess"
[task]
name = "swedl/csv-canon"
authors = [{ name = "WorkBuddy Benchmarks", email = "benchmarks@example.invalid" }]
description = "Write a byte-exact CSV-to-TSV canonicaliser with strict error codes and numeric normalisation."
keywords = ["csv", "cli", "spec-c... | FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
bash coreutils \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /workspace
COPY data/ /workspace/data/
CMD ["/bin/bash"]
| #!/usr/bin/env bash
# Oracle solution: csv module for RFC4180, Decimal for exact numeric rewriting.
set -euo pipefail
cd "$TB_WORK"
mkdir -p bin
cat > bin/canon <<'PYEOF'
#!/usr/bin/env python3
import csv
import re
import sys
from decimal import Decimal, InvalidOperation
from pathlib import Path
NUMERIC = re.compile(... | {
"test.sh": "#!/usr/bin/env bash\n# Verifier entrypoint. Runs the pytest suite and lets its exit code stand as the\n# reward signal (0 = solved).\nset -uo pipefail\ncd \"$TB_ROOT/tests\"\npython -m pytest -v --tb=short -p no:cacheprovider test_outputs.py\n",
"test_outputs.py": "import os\nimport subprocess\nfrom p... | {
"setup": "",
"setup_timeout_sec": 120,
"files": {
"data/orders.csv": "id,sku,qty,price\r\n3,SKU-9,2,1.50\r\n1,SKU-2,10,2\r\n2,SKU-1,5,1e3\r\n1,SKU-1,5,0.75\r\n"
},
"test_cmd": "",
"workdir": "workspace",
"requires": [
"bash",
"python"
],
"baseline_failures": [
"test_outputs.py::test... |
tbdl-build-repair | # Make the report build work again
`build.sh` is supposed to regenerate `dist/report.txt` and then run the project's
own test suite. Right now it does neither:
```
$ bash build.sh
build.sh: line 5: OUTDIR: unbound variable
```
Nothing in the repository is sacred except the inputs and the tests. Fix the
build so that... | WorkBuddy Benchmarks | benchmarks@example.invalid | hard | software-engineering | [
"build",
"shell",
"debugging"
] | pytest | 600 | 120 | 25 | 90 | # Terminal-Bench task definition
instruction: |
# Make the report build work again
`build.sh` is supposed to regenerate `dist/report.txt` and then run the project's
own test suite. Right now it does neither:
```
$ bash build.sh
build.sh: line 5: OUTDIR: unbound variable
```
Nothing in the repository ... | schema_version = "1.4"
source = "TerminalBench-DockerLess"
[task]
name = "swedl/build-repair"
authors = [{ name = "WorkBuddy Benchmarks", email = "benchmarks@example.invalid" }]
description = "Repair a shell build with three independent faults so it produces the expected report and passes its own suite."
keywords = ["... | FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
bash coreutils \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /workspace
COPY . /workspace/
CMD ["/bin/bash"]
| #!/usr/bin/env bash
# Oracle solution: three independent repairs -- the shell variable typo and the
# missing output directory, the dropped final record, and the truncated mean.
set -euo pipefail
cd "$TB_WORK"
cat > build.sh <<'SHEOF'
#!/usr/bin/env bash
set -euo pipefail
OUT=dist
mkdir -p "$OUT" build
python src/ge... | {
"test.sh": "#!/usr/bin/env bash\n# Verifier entrypoint. Runs the pytest suite and lets its exit code stand as the\n# reward signal (0 = solved).\nset -uo pipefail\ncd \"$TB_ROOT/tests\"\npython -m pytest -v --tb=short -p no:cacheprovider test_outputs.py\n",
"test_outputs.py": "import os\nimport subprocess\nfrom p... | {
"setup": "",
"setup_timeout_sec": 120,
"files": {
"build.sh": "#!/usr/bin/env bash\nset -euo pipefail\n\nOUT=dist\nmkdir -p \"$OUTDIR\"\n\npython src/gen.py data/input.txt | tee build/gen.log > \"$OUT/report.txt\"\n\npython -m pytest tests -q\n",
"data/input.txt": "alpha,10\nbeta,20\ngamma,31\ndelta,40\... |
TerminalBench-DockerLess
Terminal-Bench tasks are directories (instruction, environment, solution, tests)
executed inside a Docker image. This is the same task model with the image
replaced by a setup script, so a trial needs only bash, git and python —
no daemon, no network, no build step.
Rows carry the classic Terminal-Bench task.yaml fields, a rendered
task.toml in the Harbor 1.4 schema, and the whole task directory inline. One
extra dockerless object says how to build the environment without Docker.
TerminalBench-DockerLess.jsonl 4 tasks, 52.5 KiB (~13.4k tokens)
build_dataset.py flattens tasks/ into rows, then verifies the file
run_harness.py trial runner: --solution, --baseline, --predictions
tasks/ the four task directories (source of truth)
tools/validate.py schema, leakage and non-triviality checks
tools/make_controls.py builds the partial-credit negative control
tools/mk_access_log.py regenerates the access.log fixture
reports/ harness output for solution / baseline / partial
Tasks
| task_id | difficulty | category | verifier tests | fails before any agent | oracle |
|---|---|---|---|---|---|
tbdl-access-log-report |
medium | data-processing | 10 | 10 | pass |
tbdl-git-recovery |
hard | software-engineering | 10 | 9 | pass |
tbdl-csv-canon |
hard | data-processing | 8 | 8 | pass |
tbdl-build-repair |
hard | software-engineering | 4 | 4 | pass |
Difficulty is kept Terminal-Bench-shaped: each task needs real terminal work across several steps and fails if any one part is skipped.
- access-log-report — a damaged nginx-style log where the user-agent carries
escaped quotes, so splitting on
"breaks; produce an exact JSON aggregate, a nearest-rank p95, a malformed-line index and a gzip copy, idempotently. - git-recovery — restore a deleted module from the right historical
revision, resurrect an unreachable commit found via
git fsck, tag a release commit, ignore two untracked artefacts without deleting them, and leave a clean tree without rewriting the five original commits. - csv-canon — write a byte-exact CSV→TSV canonicaliser: BOM, CRLF, RFC 4180
quoting, embedded newlines,
Decimalnumeric rewriting, byte-order sorting, and three distinct exit codes with exact stderr lines. - build-repair — a build that dies on an unbound shell variable, then on a
missing output directory, then produces a report missing its last record with a
truncated mean; all three must be fixed without touching
data/ortests/.
Row schema
| field | notes |
|---|---|
task_id |
tbdl-<task> |
instruction |
the full instruction.md text |
author_name, author_email |
as in task.yaml |
difficulty, category, tags |
easy / medium / hard |
parser_name |
pytest |
max_agent_timeout_sec, max_test_timeout_sec |
enforced by the harness |
expert_time_estimate_min, junior_time_estimate_min |
author estimates |
task_yaml |
the row rendered as a classic Terminal-Bench task.yaml |
task_toml |
the row rendered as a Harbor task.toml (schema_version = "1.4") |
dockerfile |
the original image spec, kept for fidelity (not executed) |
solution |
solution/solve.sh, the oracle |
tests |
{"test.sh": ..., "test_outputs.py": ...} |
dockerless.setup |
replaces the Dockerfile: builds the environment |
dockerless.files |
workspace snapshot written before setup runs |
dockerless.test_cmd |
empty = run tests/test.sh |
dockerless.baseline_failures |
verifier tests that already fail before any agent acts |
How the environment is replaced
| Terminal-Bench | here |
|---|---|
environment/Dockerfile + docker build |
dockerless.setup run in a fresh directory |
/workspace |
$TB_WORK |
/logs/verifier/reward.txt |
the harness computes reward from the pytest run |
tests/test.sh |
same file, run with cwd=$TB_WORK |
Each trial gets a throwaway root:
$TB_ROOT/
workspace/ agent cwd
home/ HOME
tmp/ TMPDIR
bin/ prepended to PATH (contains a python3 shim)
tests/ verifier, uploaded after the agent finishes
Running it
python -m pip install pytest # the only dependency
python build_dataset.py # rebuild + verify (oracle 4/4, baseline 0/4)
python run_harness.py --solution # oracle, expect 4/4
python run_harness.py --baseline # no agent, expect 0/4
python run_harness.py --predictions predictions/partial.jsonl
A prediction is {"task_id", "agent_script"}: a shell script run in the
workspace, which is the Docker-free stand-in for "the agent did its work".
resolved means every verifier test passed (reward 1.0), the Terminal-Bench
rule.
Verified results
$ python run_harness.py --solution
tbdl-access-log-report 1.0 10/10
tbdl-git-recovery 1.0 10/10
tbdl-csv-canon 1.0 8/8
tbdl-build-repair 1.0 4/4
resolved 4/4 (100.0%)
$ python run_harness.py --baseline -> 0/4
$ python run_harness.py --predictions predictions/partial.jsonl
tbdl-access-log-report 0.0 9/10 p95 off by one rank
tbdl-git-recovery 0.0 5/10 wrong revision, no wip rescue
tbdl-csv-canon 0.0 5/8 BOM kept, rows unsorted
tbdl-build-repair 0.0 1/4 shell fixed, Python faults left
resolved 0/4 (0.0%)
The partial control is the important one: each attempt is a plausible half-fix and each still scores zero, while the per-test counts show the verifier is grading the whole task rather than one easy assertion.
build_dataset.py refuses to write a row when a task already passes with no
agent at all, and it re-runs the finished JSONL through the harness in both
modes, so the file cannot drift from its verification.
Budget
Measured for max_tokens = 2048, context = 240000:
- instruction: 1.3k–2.4k characters (~350–600 tokens) per task
- whole dataset: 52.5 KiB ≈ 13.4k tokens, so all four rows fit in one context
- each task is solvable with many short turns: the oracle scripts are 40–90 lines total, so no single completion needs more than ~1k tokens
Deliberate deviations
setup.shinstead of a Dockerfile. The Dockerfile is still shipped in the row for fidelity, but the environment is rebuilt by a script so the benchmark runs on a laptop with no daemon.- Host toolchain, not a pinned image. Tasks are written against
bash+git+python+ coreutils only, and the verifier avoids symlinks, signals,/procand permission bits so it behaves the same on Linux, macOS and Windows/Git Bash. agent_scriptpredictions. A full Terminal-Bench harness drives a model turn by turn; here a prediction is the script that performs the same actions, which makes the benchmark reproducible without an inference loop.- Static
reward. Multi-step tasks andmulti_step_reward_strategyare not used; every task is single-step with an all-or-nothing reward.
Platform note
On Windows, bash on PATH is often the WSL launcher. The harness resolves a
real POSIX shell (Git Bash), proves it works with a probe, and exports it to the
verifier as TB_BASH; verifier code that shells out should use
os.environ.get("TB_BASH", "bash"). A python3 shim is placed in $TB_ROOT/bin
so scripts with #!/usr/bin/env python3 run unchanged.
- Downloads last month
- 59