These are raw agent trajectories from a benchmark run. They contain verbatim model output, tool calls, and excerpts of source code from the upstream repositories under evaluation. Access is granted for research and evaluation purposes. Please tell us who you are and how you intend to use the data.

Terminal-Bench 2.1 explore-17 — mcode / MiniMax-M3 harness variance

Three complete 17-task runs of the same dataset ref with the same agent and model, differing only in execution substrate and concurrency, plus one isolated rerun. The point of the bundle is not the resolve rate — it is how much the resolve rate moves when nothing about the task or the model changes.

Same everywhere: dataset ai-solution-finetune/terminal-bench-2-1-explore-17 at sha256:3325232d817522c1decf05dd3d0269e69f19ed0fc368bad0ef0b20e2b0538d30, agent agents.mcode_thinking.agents:MCodeThinking, model minimax/MiniMax-M3, thinking: on. Governing commit 4240900 on bench/tb21-explore17-mcode.

The runs

job	substrate	concurrency	wall	pass	Harbor mean	resolve / scored	errored	note
`tb17-local-parallel4`	docker	4 (measured)	1h01m	8/17	0.4706	8/17 = 0.4706	7	superseded — see below
`tb17-local-serial`	docker	1	4h36m	11/17	0.6471	11/16 = 0.6875	5	the headline run
`tb17-modal-serial`	modal	1	4h08m	9/17	0.5294	9/17 = 0.5294	7
`tb17-local-serial-dbwal-rerun`	docker	1	7m	0/1	0.0000	0/1	0	isolated rerun, `agent_setup_timeout_multiplier=4`

Read 0.4706 vs 0.6471 vs 0.5294 as a spread on one 17-task suite, not as three model scores. At n=17 binary, one task is 5.9 points. Nothing here is separated by more than 3 tasks.

`tb17-local-parallel4` is not a competing score — and not only because of concurrency

The repo notes recommend discarding this run, and that recommendation stands. It is published as the concurrency arm of the ablation, not as a number to quote. Two independent reasons, and the second one is a confound the notes do not state plainly:

Rate limiting. Three trials died on MiniMax 1002 (RPM) — fix-ocaml-gc, make-mips-interpreter, sanitize-git-repo. Two of them (fix-ocaml-gc, sanitize-git-repo) flip 0 → 1 when rerun serially.
The agent build is different. pytorch-model-recovery fails in this run with error: unknown option '- You are given...': its instruction.md opens with - , and the stock adapter appended it to mcode exec as a bare positional. MCodeThinking gained a -- insertion for exactly that case between this run and the serial one, and the task goes 0 → 1. Verifiable in the bundle: grep -l 'unknown option' jobs/*/*/agent/mcode.stderr matches 1 trial in tb17-local-parallel4 and 0 in the other two jobs. Exactly 1 of 17 instructions is affected.

So of the three tasks that separate parallel-4 from serial, only two are attributable to concurrency. Concurrency alone would put this arm at 10/17 = 0.588, not 0.471.

An exception does not mean the trial failed

19 of the 52 trials raised a harness exception. 18 of those 19 still carry a real verifier reward, and two of them scored 1.0. error and reward are independent columns in results.jsonl for this reason; do not filter on error to find failures.

tb17-modal-serial / build-cython-ext — AgentTimeoutError, reward 1.0. The agent was killed at the 900s cap (20:42:16Z → 20:57:17Z); the verifier ran 9 seconds later and passed. The work was already done.
tb17-modal-serial / fix-ocaml-gc — ApiRateLimitError, reward 1.0.

Exactly one trial across all 52 has no reward at all: tb17-local-serial / db-wal-recovery, AgentSetupTimeoutError. Harbor's job-level mean divides by all 17 trials while labelling the eval block n_trials: 16, so that unscored trial is silently read as a zero — which is why the serial run's mean over scored trials is 11/16 = 0.6875, not 0.6471.

tb17-local-serial-dbwal-rerun exists to close that hole. db-wal-recovery alone, agent_setup_timeout_multiplier=4, 7 minutes, reward 0. The failure is genuine, so counting it as a zero is correct — but that is a measured fact, not an assumption Harbor was entitled to make.

Per-task agreement

1/0 is the reward; the suffix is the exception, if any. TMO = AgentTimeoutError, RATE = ApiRateLimitError, EXIT = NonZeroAgentExitCodeError, SETUP = AgentSetupTimeoutError, - = no reward recorded.

task	parallel-4	serial	modal	all three agree
`build-cython-ext`	1	1	1/TMO	yes
`cobol-modernization`	1	1	1	yes
`custom-memory-heap-crash`	1	1	1	yes
`db-wal-recovery`	0	−/SETUP	0/RATE	see above
`extract-elf`	1	1	0	no
`fix-code-vulnerability`	1	1	1	yes
`fix-git`	1	1	1	yes
`fix-ocaml-gc`	0/RATE	1	1/RATE	no
`git-leak-recovery`	1	1	1	yes
`make-doom-for-mips`	0/TMO	0/TMO	0/TMO	yes
`make-mips-interpreter`	0/RATE	0/EXIT	0/RATE	yes
`modernize-scientific-stack`	1	1	1	yes
`pytorch-model-recovery`	0/EXIT	1	1	no (adapter fix)
`query-optimize`	0	0	0/TMO	yes
`regex-chess`	0/TMO	0/TMO	0	yes
`sanitize-git-repo`	0/RATE	1	0	no
`schemelike-metacircular-eval`	0/TMO	0/TMO	0/EXIT	yes

Pairwise: serial vs modal 14/17, parallel-4 vs serial 13/17, all three 12/17.

The repo notes say 15 of 17 for serial vs modal. Both are right, and the gap is db-wal-recovery: on the raw records serial has no reward there and modal has 0, which is a disagreement; once the isolated rerun establishes serial's true value is 0, they agree. 14/17 is what the records say, 15/17 is what the records plus the rerun say.

The genuine substrate disagreements are extract-elf and sanitize-git-repo, both 1 → 0 on Modal, both verified in the upstream notes as real agent failures rather than infra.

Docker's proxy was hiding a rate limit

The two docker runs route egress through a host bridge (HTTPS_PROXY=http://host.docker.internal:3128). Modal runs with direct egress and no proxy — visible in the configs, which carry no proxy variables at all.

That difference is not cosmetic. The corporate egress proxy in front of the docker runs was acting as an accidental rate limiter, and removing it exposed a different MiniMax cap: RPM (1002) is what parallel-4 hit, TPM (1039) is what Modal hit at concurrency 1. Serial execution fixes the first and does nothing for the second. All three of Modal's TPM-affected trials nevertheless scored what docker scored, so rate limiting did not move the modal headline.

Cost

job	input	output	cache read	trials counted
`tb17-local-parallel4`	380,638	105,098	6.9M	10/17
`tb17-local-serial`	660,354	194,384	26.6M	12/17
`tb17-modal-serial`	738,715	442,079	61.9M	10/17

These totals are not comparable across jobs. Usage is stamped only on turn.completed, so a trial killed mid-turn reports 0 tokens despite having consumed them — the "trials counted" column is how many trials contributed. The totals understate every run, and understate the rate-limited ones most.

Two further traps in this provider's accounting:

reasoningTokens is always 0. Reasoning is folded into outputTokens. Do not read it as evidence that thinking was off.
Thinking-on is only observable as model.variant == "thinking", which also appears only on turn.completed. results.jsonl carries it as model_variant_on_wire; it is null on the 22 trials that never completed a turn. The thinking: on kwarg is set on all 52 rows.

regex-chess alone is 24.9 MB of trajectory in the serial run and 44.6M of Modal's cache-read.

Read-set localization is scored on only one job

readset_* columns are populated for 7 trials of tb17-local-serial only. The modal per-task read-set numbers quoted in the repo notes were computed post-hoc and their artifacts were not retained in the job dirs. readset_tb.txt (full-tree gt) survives for 16 serial trials and is carried as readset_f1_full_gt.

subset	n	f1	precision	recall	hit_file	hit_region
all edits-only tasks	7	0.0165	0.0086	0.5478	0.5342	0.5509
excl. history-rewrite	5	0.0101	0.0053	0.5955	—	—

Classic read-set signature: recall ≈ 0.6 at precision ≈ 0.005 — exploration covers the regions the fix touches while reading ~200× more than it needs.

The denominator is the real finding: only 7 of 17 tasks are scorable at all, and really only 3–4. The other 10 are ALL_GT_CREATED — the gold solution only writes new files, so there is no pre-existing region to localize. TB 2.1's explorer subset is a strong resolve benchmark and a weak read-set-localization benchmark. fix-git and sanitize-git-repo are git-history rewrites whose gt is a tree diff rather than "what the fix edits"; treat those two rows as unreliable.

Files

results.jsonl                     52 rows, one per trial — the viewer renders this
jobs.json                         per-job rollup, including measured concurrency
run-notes.md                      longer write-up: causes, infra, reproduction
jobs/<job>/config.json            the Harbor job config as submitted
jobs/<job>/result.json            Harbor's job-level result and per-eval stats
jobs/<job>/lock.json              resolved task refs and agent kwargs
jobs/<job>/job.log
jobs/<job>/<trial>/               the raw trial dir, uncompressed

Each trial dir holds agent/mcode.jsonl (the full event stream), agent/mcode-sessions/**/messages.jsonl, agent/mcode.stderr, verifier/ctrf.json (the pytest report), verifier/reward.txt, verifier/test-stdout.txt, exception.txt on errored trials, and readset_tb*.txt where read-set scoring ran.

`results.jsonl` schema

Provenance: task, job, arm, substrate, n_concurrent_declared, agent_class, model, thinking, model_variant_on_wire, dataset, dataset_ref, task_ref, task_checksum. Outcome: trial_name, reward, scored, error, errored_but_passed, n_tests, n_passed, n_failed. Cost: wall_clock_min, agent_exec_min, n_input_tokens, n_output_tokens, n_cache_read_tokens, n_turns, n_reasoning_items, n_tool_calls, n_agent_messages, trajectory_bytes, started_at, finished_at. Read-set: readset_f1, readset_precision, readset_recall, readset_hit_file_rate, readset_hit_region_rate, readset_n_predicted_files, readset_n_predicted_regions, readset_f1_full_gt.

n_concurrent_declared is null for tb17-local-parallel4 because that run did not set it and took Harbor's default. jobs.json carries n_concurrent_measured, swept from the trial intervals: 4, 1, 1, 1.

Four caveats before you quote a number

n=17, binary. One task is 5.9 points. The 0.47 → 0.65 spread is 3 tasks.
Harbor's mean divides by all trials while labelling the block with the scored count. Recompute from results.jsonl; report the error count beside any mean.
error and reward are independent. 18 of 19 errored trials are scored, two of them passing.
parallel-4 straddles an agent-code change, so it is not a clean concurrency ablation. See above.

Expected secret-scanner hits

Three sanitize-git-repo trial dirs contain credential-shaped strings — AKIA1234…, ghp_aBcD…, and two hf_… values. These are task fixtures, not live credentials. sanitize-git-repo ships a git repo with secrets planted in its history and asks the agent to scrub them; the strings come from the upstream Terminal-Bench task data and appear in the trajectories because the agent read and reported them. They are not from the run environment. Nothing in this bundle contains a real key: MINIMAX_API_KEY appears in the configs only as the unexpanded literal ${MINIMAX_API_KEY}.

Access and licensing

Gated: access is granted manually, for research and evaluation. The trajectories quote verbatim source from the upstream Terminal-Bench 2.1 task images, each under its own license, which is why this is license: other. The Harbor configs, results.jsonl, jobs.json and these notes are ours.

Reproducing this bundle

cd swe-explore-fix
python3 scripts/build_tb_run_log_dataset.py --out ~/hf_upload/tb-explore17-mcode-m3-harness-variance

The builder asserts its per-trial walk against Harbor's n_total_trials, n_trials and n_errors for every job, so a truncated log tree fails the build rather than shipping a short index. Its token and read-set aggregates were cross-checked against the independent write-ups in the source repo and match to the digit (serial 854,738 tokens / 26.6M cache-read; modal 1,180,794 / 61.9M; read-set f1 0.0165 at n=7 and 0.0101 at n=5).

Downloads last month: 30

Total file size:

184 MB

You need to agree to share your Hugging Face information to access this dataset