---
license: mit
task_categories:
- text-generation
language:
- en
tags:
- code
- agent
- benchmark
- tool-use
- swe
pretty_name: SACB (Simple Agent Coding Benchmark)
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: test
    path: data/test-*
  - split: extended
    path: data/extended-*
---

# SACB — Simple Agent Coding Benchmark

A multi-turn agentic coding benchmark that needs **no Docker**. The model is
given a small but real repository, a deliberately narrow tool set, and a bug
report. It drives its own conversation until it declares itself finished, and is
then graded by running a test suite it was never allowed to see.

Built for [`llama-eval`](https://github.com/ggml-org/llama.cpp) (`--dataset agentic`),
but the records are self-contained and usable by any harness.

## Why it exists

Most agentic coding benchmarks need a container per task, because each one drags
in a different framework and toolchain. SACB deliberately restricts itself to
two languages with lightweight native sandboxes and a tiny dependency set, so a
run needs a venv and, for the TypeScript half, node — nothing more.

## Design

Three constraints, all deliberate:

**No shell, and no way to run the tests.** The only feedback channel is a
`lint` tool. A syntax or type error can be driven out mechanically; a logic
error has to be reasoned about. A harness that lets an agent iterate against the
test suite measures something closer to search than to understanding.

**Two edit tools**, one line-addressed and one content-addressed. Which one a
model reaches for, and whether it keeps line numbers straight after its own
earlier edit, is itself a signal.

**Tests never touch the working tree.** They are held outside it and copied into
a throwaway copy only after the agent stops, so they can be neither read nor
edited.

The expected tool set is `list_files`, `read_file` (with line-range narrowing),
`search`, `edit_lines`, `edit_replace`, `write_file`, `lint`, `finish`.

## Splits

| split | tasks | contents |
|---|---|---|
| `test` | 60 | the default benchmark |
| `extended` | 129 | everything validated, including the easy `ledger` tier |

The `test` split is a deliberate selection, not a sample. Difficulty here is a
property of *composition*: it is 10 single-defect tasks plus 50 compound tasks,
which is what places a leading small model in the intended band.

## Repositories

Every task is an overlay on one of three hand-written base repositories. The
base is the *correct* code, so the reference fix cannot fail to work.

| repo | language | size | role |
|---|---|---|---|
| `flow` | Python | 989 lines, 13 modules | workflow scheduler |
| `router` | TypeScript | 578 lines, 12 modules | HTTP router |
| `ledger` | Python | 417 lines, 6 modules | event-sourced inventory (easy tier, `extended` only) |

## Fields

| field | meaning |
|---|---|
| `task_id` | unique id |
| `repo`, `lang`, `category`, `difficulty` | metadata |
| `instruction` | the bug report shown to the model |
| `files` | JSON object: path → contents. The starting tree |
| `tests` | JSON object: hidden tests, **never** placed in the agent's tree |
| `gold` | JSON object: the reference fix, for validation |
| `fail_to_pass` | tests that must go from failing to passing |
| `pass_to_pass` | tests that must stay passing |
| `n_tests` | total tests |

`files`, `tests` and `gold` are JSON strings; parse with `json.loads`.

## Scoring

A task is **resolved** when every `fail_to_pass` test passes *and* no
`pass_to_pass` test broke. Report the fraction of `fail_to_pass` alongside:
many tasks carry several independent defects, and that fraction separates
"fixed two of the three faults" from "changed nothing".

`fail_to_pass` and `pass_to_pass` are **derived**, never hand-written — the
tests are run once against the defective tree and once against the reference,
and the sets fall out of the difference. A task whose defect no test exercises,
or whose reference fix does not itself pass, is rejected rather than shipped.

## Calibration

Measured against **Qwen3.5-4B** (Q6_K), 19 episodes on the hard repositories:

| tier | resolved |
|---|---|
| single defect | 3/5 |
| compound (2–4 defects) | 1/14 |

The `test` split projects **~16%** on those rates. Typical episode: 4–12 turns,
16–134k cumulative tokens (median ~40k), 4–11k peak context.

### What actually controls difficulty

Measurement contradicted the obvious guesses, so they are worth recording:

* **Repository size dominates defect count.** A *single*-defect task on `flow`
  went unresolved while a *three*-defect compound on `ledger` resolved
  completely. What makes these tasks hard is orienting in a repository too large
  to read at once. To make the benchmark harder, add a larger repository — not
  more defects per task.
* **Sub-defect success is correlated, not independent.** Two-defect compounds
  resolve near 50%, not the 25% that multiplying probabilities predicts: the
  expensive part is orienting in the code, and that cost is paid once and shared
  across every defect in the same task.
* **Instruction vagueness barely matters.** Rewriting reports from diagnosis to
  bare symptom moved the number far less than expected.

### A harness note worth heeding

If your harness ends an episode as soon as the model emits no tool call, you
will measure a **fake 0%**. Models routinely narrate their analysis in prose
mid-task; treating that as "done" ends the episode with no edits. Send a neutral
nudge and let it continue — roughly one episode in four exits that way.

## License

MIT. All repositories, defects and tests are original work written for this
benchmark; no upstream code is redistributed.