tb-full-data

The full corpus results, not a selection. Every task of two corpora that our v13 audit judged and that no earlier release of ours already holds, with its judgement, its rollout record and, where one exists, a solution whose replay in a fresh sandbox scored 1:

• TMAX: allenai/tmax-15k-open-instruct at revision 7b090eca (14,601 tasks).
• CalibForge: AweAI-Team/CalibForge at revision fb1e7544 (5,431 tasks), the tasks not reviewed before.

split	meaning	rows	with a replay-verified solution	security-domain rows
tmax_clean	TMAX, judged clean (tier SEED, verdict CLEAN) and a replay-verified solution	5,763	5,763	499
tmax_repair	every other judged TMAX task	5,765	2,723	726
calibforge_clean	CalibForge, judged clean and a replay-verified solution	2,897	2,897	239
calibforge_repair	every other judged CalibForge task	1,768	1,162	159

from datasets import load_dataset
ds = load_dataset("Fzz1/tb-full-data")   # ds["tmax_clean"], ds["tmax_repair"], ds["calibforge_clean"], ds["calibforge_repair"]

How a task was classed

The same three steps and the same rule for both corpora.

1. Judged. Each task was judged once under rubric v13. The judge read the task's instruction, its environment and its verifier, never a reference solution, and returned a tier and a verdict.
   • TMAX: most verdicts come from Kimi K3 at reasoning effort low (tier_source v13_k3_rest, v13_k3_rejudge, v13_k3_fix, v13_k3_fill); the rest are earlier verdicts under the same rubric (v13_prior).
   • CalibForge: Kimi K3 at reasoning effort low under v13-harbor3, the form of rubric v13 for packaged tasks (tier_source v13_harbor_row:cfr_h3).
2. Rolled out. A model attempted the task once in a sandbox with the task's own verifier. A task that scored 0 was attempted up to twice more at reasoning effort max, stopping at the first attempt that scored 1.
   • TMAX: DeepSeek V4.1 Flash, effort high for the first attempt, max for the retries.
   • CalibForge: two models. The first attempt of 544 tasks ran on DeepSeek V4.1 Flash at effort high with top_p 1.0, and of 4,110 tasks on Kimi K3 at effort low with top_p 0.95 (the only top_p its provider accepts). Every retry ran on Kimi K3 at effort max with top_p 0.95. Of the 4,059 replay-verified CalibForge solutions, 418 come from DeepSeek and 3,641 from Kimi K3; solution_model names the one on each row.
3. Replayed. The task's first reward-1 attempt counts only if its recorded action sequence, replayed once in a fresh sandbox of the attempt's own size, is graded 1.0 again. That one replay decides; the reward the model obtained during its own episode is never enough.

*_clean = tier SEED, verdict CLEAN, and a replay-verified solution.

*_repair = every other judged task; none is held back:

why	tmax_repair	calibforge_repair
FLAGGED, verdict ANSWER-LEAK	3,091	554
FLAGGED, verdict INSTR-VERIFIER-MISMATCH	1,484	769
FLAGGED, verdict UNSTABLE-REWARD	110	48
FLAGGED, tier without a verdict (an earlier judgement recorded only the tier)	48	0
UNSURE (a deciding fact left open)	26	38
SEED/CLEAN, no attempt scored 1	977	298
SEED/CLEAN, expected zero: one attempt scored 0 and was not retried	0	22
SEED/CLEAN, an attempt scored 1 but its replay graded 0	28	29
SEED/CLEAN, an attempt scored 1 but its replay ended in an error and was not graded	0	6
SEED/CLEAN, no counted attempt	1	4

A repair row carries a solution when one of its attempts was replay-verified, and none otherwise. Notes on the CalibForge column:

• "Expected zero" tasks have a verifier that needs a fixture the task's loader does not carry, so they were attempted once and not retried.
• A replay that ended in an infrastructure or replay error was not graded, so it verified nothing; the task stays in repair (replay_status names the error).
• The tasks with no counted attempt used up their attempt budget on infrastructure failures (sandbox setup or sandbox errors, and two agent-stage runtime errors), none of them an error from the model provider.
• Of the UNSURE rows, 6 (UNSURE with a verdict other than CLEAN) were never rolled out.

Answer leaks are included, in the repair splits. Unlike Fzz1/tb-training-mix-agentpick, which never ships a task with verdict ANSWER-LEAK, this dataset ships every judged task. A leak means a reward can be obtained without doing the core work, so filter on verdict before training on a repair split: ds["tmax_repair"].filter(lambda r: r["verdict"] != "ANSWER-LEAK").

What is not here

TMAX: 3,073 corpus tasks are not uploaded. Each is listed in metadata/split_assignment_tmax.tsv with its reason:

• excluded_in_release 1,750: already published in Fzz1/Tmax-Tasks-Clean, Fzz1/tb-training-mix-agentpick or Fzz1/tb-training-mix. Tasks we already reviewed and published are not redone, and no task appears in two of our datasets.
• excluded_reviewed_not_shipped 279: reviewed for one of those datasets and listed in its split file, but not uploaded there (excluded as a leak, or held). They were already decided and are not redone.
• excluded_killed_earlier 723: removed by an earlier review or gate.
• excluded_reviewed_earlier 321: reviewed under an earlier rubric and not judged again.
• excluded_not_judged 0.

CalibForge: 766 corpus tasks are not uploaded, each listed in metadata/split_assignment_calibforge.tsv with its reason. All of them were reviewed earlier for Fzz1/tb-training-mix-agentpick:

• excluded_in_release 627: published there (calibforge_clean, calibforge_repair).
• excluded_killed_earlier 139: judged an answer leak there and not shipped.
• excluded_reviewed_not_shipped 0, excluded_not_judged 0.

Columns

All four splits share one schema. The first 70 columns are those of Fzz1/tb-training-mix-agentpick, with the same names, order and types; see that card for each one. Here:

• solution is the replay-verified action sequence (solution_format terminus_tmux_actions_v1, a JSON list of tmux keystroke actions, not a shell script). solution_replay_reward is the replay's grade, and solution_actions_sha256 is the sha256 of exactly these bytes.
• solution_model is the model of the replayed attempt, as named by the endpoint it was called through: deepseek-flash is DeepSeek V4.1 Flash, moonshotai/Kimi-K3 is Kimi K3. solution_reasoning_effort is that attempt's effort.
• tier, verdict, blocking_fields, note_fields, repair_hint and v13_pin_candidates come from the judgement row. Security-domain rows carry no repair_hint and no pin candidates.
• req_cpus, req_memory_mb and est_disk_mb are the sandbox the first counted attempt ran in. runtime_peak_ram_mb and runtime_peak_disk_mb are that attempt's measured peaks, left null where the run hit its memory ceiling.
• prepared_row_json is the training side's own converter output for a TMAX task; it is empty on CalibForge rows, as in agentpick's CalibForge splits.
• dockerfile is the Dockerfile the rollout ran: TMAX's is generated from the task's image (below); CalibForge's is the package's own, except on rows with dockerfile_repaired true, where it is a single FROM aweaiteam/calibforge@sha256:<digest> line (the task's pinned image) because the training loader refuses the package's own Dockerfile.
• tb21_best_rank and tb21_neighbour_of are empty: this dataset is the whole corpus, not a re-rank.

Added columns. A null means the value does not exist for the row: the attempt was not taken, the task was never rolled out or replayed, or (peaks and CPU) the attempt is censored, so its reading would only be a lower bound.

column	meaning
solution_source	t14_replay_verified when solution is a replay-verified attempt (:drop_between_last_markers when the replayed sequence dropped the actions between its last two completion markers), else empty
rollout_attempts	counted attempts over all passes, i.e. attempts the model made and the verifier graded (0 if never rolled out)
rollout_reward_best	the best in-episode reward over those attempts, before any replay
rollout_best_attempt, rollout_best_effort	the first attempt that reached the best reward (pass1, retry1, retry2) and its reasoning effort
rollout_reward_pass1, rollout_reward_retry1, rollout_reward_retry2	each counted attempt's reward; a retry is null when it was not taken (pass 1 scored 1, or retry 1 did)
rollout_rung	the sandbox of the first counted attempt, cpu/memory GiB/disk GiB (it starts at 1/1/1 and runs once more at 4/8/10 if it hits a ceiling)
rollout_wall_s, rollout_agent_turns, rollout_api_calls, rollout_finish_reason, rollout_outcome	the first counted attempt: wall time, turns, model calls, how the episode ended (submit, time budget, ...) and pass/fail
rollout_prompt_tokens, rollout_cache_hit_tokens, rollout_completion_tokens, rollout_reasoning_tokens, rollout_total_tokens	the first counted attempt's token usage (total = prompt + completion; reasoning is part of completion)
rollout_total_tokens_all_attempts	tokens of every pass-1 attempt, including attempts lost to infrastructure and the ceiling re-run
rollout_attempts_launched, rollout_attempts_killed, rollout_attempts_interrupted	pass-1 bookkeeping: attempts started, ended by an infrastructure failure, and stopped by a pause (neither of the last two counts)
rollout_peak_ram_mb, rollout_peak_disk_mb	the first counted attempt's measured peaks during the agent's work; null when the attempt is censored (it hit a sandbox ceiling, was killed for memory, or its readout failed)
rollout_peak_ram_mb_full, rollout_peak_disk_mb_full	the same, read again after the verifier ran, so grading is included
rollout_peaks_usable, rollout_censored_reason	whether the peaks are measurements (false: a lower bound at a ceiling, and why)
rollout_cpu_seconds, rollout_cpu_avg_cores, rollout_cpu_peak_cores	the first counted attempt's measured CPU: CPU time, average cores in use and the sampled peak; null when the attempt is censored
rollout_model_returned	the model name every response of the first counted attempt reported (on CalibForge, deepseek-flash or moonshotai/Kimi-K3)
rollout_retry1_*, rollout_retry2_* (wall_s, finish_reason, total_tokens)	the counted max-effort retries; rollout_retries_tokens_all_attempts adds attempts lost to infrastructure
replay_status, replay_reward	the deciding replay of the task's reward-1 attempt: GRADED and its grade, or why it could not be graded
replay_episode_pass	which attempt was replayed (pass1, retry1, retry2)
replay_rung, replay_cpu_applied, replay_memory_gib, replay_disk_gib	the attempt's sandbox and what the replay sandbox actually received (CPU from the rung)
replay_wall_s, replay_s	the replay's wall time, and the part spent re-typing the actions
replay_transform	drop_between_last_markers when the replayed sequence was transformed, else null

runtime_cpu_seconds (null in agentpick) is filled here with rollout_cpu_seconds.

metadata/split_assignment_tmax.tsv and metadata/split_assignment_calibforge.tsv have one line per corpus task: its split, reason, tier, verdict, security flag, counted attempts, best reward and whether a replay verified a solution. The CalibForge file also gives the model, reasoning effort and top_p of every counted attempt (pass1_*, retry1_*, retry2_*); top_p is the value each request sent. They contain no task text.

Packages

data/tasks-<split>.tar holds each task as tasks/<task_id>/.

• TMAX: instruction.md, setup.sh and tests/test.sh, byte-identical to the upstream archive, plus environment/Dockerfile, which equals the dockerfile column (FROM <the task's image> with the setup script inlined as comments).
• CalibForge: instruction.md, task.toml and every file under environment/, tests/ and solution/, byte-identical to the upstream repository at fb1e7544. The one exception is environment/Dockerfile on rows with dockerfile_repaired true, which is the single FROM line of the dockerfile column.

Canary markers

The canary scan found 69 benchmark canary marker(s) across the uploaded files. They are kept as they are.