ai-and/termgrade-trajectories

TermGrade Trajectories: 36,144 graded attempts across six models

_{Part of TermGrade: graded environments and trajectories for terminal agents. Read the blog post.}

36,143 graded episodes · 6 models · 1,004 executable tasks · Terminus-2

21,910 of the 36,144 trials pass and can be used directly as SFT data (Apache-2.0). The 14,234 failures ship in full, with the assertion that broke.

Every command each model sent, the raw terminal output that came back, its reasoning where the model exposes it, and the per-test verdict of the verifier.

_{Companion corpus: ai-and/termgrade-environments, the environments these were graded on.}

---

Quick start

from datasets import load_dataset
from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("google/gemma-4-31B-it")   # or the model you're training

# SFT-ready chat turns: 21,910 of 36,144 trials pass
d = load_dataset("ai-and/termgrade-trajectories", "trajectories_messages")["train"]
d = d.filter(lambda r: r["messages"] and r["reward"] == 1.0)
tok.apply_chat_template([{"role": m["role"], "content": m["content"]}
                         for m in d[0]["messages"]])

# the full scaffold record: what it typed, what came back
import json
d = load_dataset("ai-and/termgrade-trajectories", "trajectories_terminus")["train"]
ep = json.loads(d.filter(lambda r: r["reward"] == 0)[0]["terminus_episode"])
for s in ep["steps"]:
    if s["source"] == "agent":
        print(s["tool_calls"][0]["arguments"]["keystrokes"])       # what it ran
        print(s["observation"]["results"][0]["content"])           # what came back

---

What ships

config	rows	download	contents
trajectories_messages	36,144	716 MB	SFT-ready chat turns
trajectories_terminus	36,144	743 MB	the full Terminus-2 episode
trials	36,144	5 MB	one row per trial, the scalar record
unit_test_results	36,074	4 MB	named test pass/fail
verifier_output	72,148	6 MB	pytest output + program stdout, two per trial

The two trajectory configs hold the same 36,144 trials with one heavy column each, so you download only the view you need. Both carry the full scalar record and join on task + model + trial.

_{70 trials were killed before the verifier ran and have no per-test report. Their reward is 0 because of the budget rule, not a test result.}

---

Results

model	k	pass@1	median trial	runtime ‡
gemma	8	0.4986	3.3 min	594 h
gemma_think	8	0.5774	13.3 min	3,287 h
qwen	8	0.6320	7.4 min	2,417 h
kimi	8	0.6770 †	5.9 min	1,929 h
deepseek	2	0.6853 †**	99.6 min	6,289 h
glm	2	0.6858 †	117.2 min	5,359 h

^† kimi, deepseek and glm are statistically tied. Paired per-task across all 1,004 tasks: glm−deepseek +0.05pp (p=0.97), kimi−glm −0.87pp (p=0.42), kimi−deepseek −0.82pp (p=0.51). qwen is separated from all three (p<0.001).

^** DeepSeek-V4-Pro numbers are for the build we graded, not the 0813 release, a newer build that shipped during our grading window. Every trial records started_at, so you can see when each one ran.

^‡ Runtime is wall clock, and roughly 20–30% of it is client retry overhead rather than model compute. A per-attempt request timeout that some responses could not clear meant attempts were abandoned and retried, so treat this column as an upper bound on what these models actually need. median trial is barely affected; the totals are, because a small number of turns dominate a sum.

What it cost

	trials	input	output	wall clock ‡
data/	36,144	3.68B	0.80B	19,875 h
extra/	26,337	3.84B	0.39B	18,915 h

Input dominates 4.6:1 because an agentic turn resends the whole transcript. glm and deepseek together are 58% of the compute for 11% of the trials.

---

trajectories_messages

A messages list of {role, content, reasoning_content, parsed}, stored as a real parquet column (not a JSON string), so it goes straight into a chat template. Present on 36,094 trials, with strict system → user → assistant → … alternation verified on every row.

field	meaning
system	the Terminus-2 prompt, byte-identical across all six models
assistant.content	the JSON the scaffold asked for: {"analysis", "plan", "commands"}, plus "task_complete": true on the turn where the agent stops
parsed == False	4% of assistant turns: the scaffold could not parse that turn's JSON, so content is the model's raw output verbatim
reasoning_content	the model's thinking, where it exposes it. Train on it as a target; do not put it in the context of later turns. The scaffold never sent it back, so replaying it inflates the prompt 2–3× over what the model actually saw

The system/user split is lossless: concatenated, they reproduce the original first prompt exactly. Terminus-2 parses text instead of using native tool calls, so assistant.content is exactly what the model wrote. One turn can carry several commands against one merged terminal screenshot, which a tool_call_id pairing can't represent. An empty commands array is legal and means "wait without acting".

messages covers the scored window only, so for trials that ran past the 12h budget it stops at the cap; those endings live in trajectories_terminus.

---

trajectories_terminus

messages is a projection; this is the whole record. It keeps what the projection drops: per-step timestamps, per-turn token counts including prefix-cache hits, the serving config that produced the episode, and the scoring verdict inline.

{
  "schema_version": 30,
  "agent": {"name": "terminus-2", "model_name": "openai/kimi-k3",
            "extra": {"parser": "json", "temperature": 0.7,
                      "llm_kwargs": {"max_tokens": 65536}}},
  "steps": [
    {"step_id": 1, "timestamp": "...", "source": "user", "message": "<prompt + task>"},
    {"step_id": 2, "timestamp": "...", "source": "agent", "model_name": "kimi-k3",
     "message": "Analysis: ...\nPlan: ...",
     "reasoning_content": "<thinking, where the model exposes it>",
     "tool_calls": [{"tool_call_id": "call_0_1", "function_name": "bash_command",
                     "arguments": {"keystrokes": "cat /app/x.py\n", "duration": 0.5}}],
     "observation": {"results": [{"content": "<raw terminal output>"}]},
     "metrics": {"prompt_tokens": 1090, "completion_tokens": 569, "cached_tokens": 512}}
  ],
  "post_cap_steps": [],
  "release_meta": {"reward": 1.0, "reward_uncapped": 1.0, "cap_s": 43200,
                   "status": "scored", "evidence": {...}, "tests": {...}}
}

field	why you'd want it
steps[].timestamp	per-turn wall clock; divided by completion_tokens, it gives that turn's generation rate
steps[].metrics	prompt_tokens, completion_tokens and cached_tokens per turn, cache behaviour that summary tables discard
steps[].tool_calls[]	function_name is bash_command or mark_task_complete; arguments holds the literal keystrokes and the duration the scaffold waited
steps[].observation	the terminal output verbatim, including the scaffold's own injected warnings
agent.extra	the serving config behind this episode: parser, temperature, max_tokens. A pass rate is only meaningful against these
post_cap_steps	turns that ran past the 12h budget, so a trial that solved its task late is still fully readable
release_meta	the scoring record inline: reward, reward_uncapped, cap flags, status, plus evidence and tests, so you don't need to join another file

steps, post_cap_steps and schema_version exist on every episode; the shape never varies across models or trials.

The 12h and 24h limits. The 12h budget is a scoring rule: a trial that exceeds it scores 0, and reward_uncapped keeps what it would have scored. 115 trials exceeded it, and 43 of those solved their task afterwards. Separately, a container still running at 24h is killed; truncated_at_s records when, and those trials can never be re-scored upward.

---

extra/

Our failed attempts: infra failures, and the extra retries it took to fill a cell. Nothing in it counts toward any number in this release, and it carries no per-test or verifier evidence. We ship it so the retry policy can be checked.

extra/trials_beyond_k.parquet   26,337
extra/messages/<model>.parquet  26,337
extra/terminus/<model>.parquet  26,337

---

Which models these are, exactly

key	model
gemma	google/gemma-4-31B-it
gemma_think	google/gemma-4-31B-it (reasoning on, same weights)
kimi	moonshotai/Kimi-K3
qwen	Qwen/Qwen3.6-27B
glm	zai-org/GLM-5.2
deepseek	deepseek-ai/DeepSeek-V4-Pro

model is the short key and the join key across every file; model_id and served_as carry the full identity on each row.

A pass rate here measures this model, with this serving config, in this scaffold, which is why we ship the per-trial metadata.

What the per-test data shows

A reward only says GLM failed a task. The per-test data says 9 of 13 tests passed, the pytest output names the failing assertion and its value, and the episode shows what the model typed.

Some things we found in it:

• Score and cost are unrelated. pass@1 spans 1.4× across these models; median tokens-per-win spans 34×.
• For some models, extra turns don't help. Paired within task, winning trials use fewer turns than failing ones for qwen and glm. The other models are flat or slightly positive.
• gemma_think ends a third of its trials in ≤2 turns: it writes a script, declares the task complete and never runs it.
• GLM emits turns with no valid tool call, and those turns are longer than its successful ones: long analysis blocks that never turn into an action.

Citation

If you use TermGrade, please cite:

@misc{calik2026termgrade,
  title        = {{TermGrade}: 1k Graded Terminal Environments, 36k Trajectories, and the {RL} Run They Trained},
  author       = {Calik, Yagiz and Wu, Jianbo and Hara, Shimpei},
  year         = {2026},
  month        = oct,
  howpublished = {\url{https://www.aiand.com/newsroom/termgrade}},
  note         = {ai\& Research blog post}
}