---
license: mit
language:
- en
configs:
- config_name: tbd
  data_files: TerminalBench-DockerLess.jsonl
tags:
- terminal
- bench
- dockerless
---
# 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, `Decimal` numeric 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/` or `tests/`.

## 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

```bash
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.sh` instead 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, `/proc` and permission bits so it behaves the same on Linux, macOS and
  Windows/Git Bash.
- **`agent_script` predictions.** 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 and `multi_step_reward_strategy` are 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.