Sudnya/test-subset-classic-eda

nano-rl trajectories

Agent trajectories from nano-rl: an LLM is asked to specify, test and then implement a small C program, which is compiled and executed inside a confined sandbox and scored against tests the model wrote before it saw its own program. When the program fails, the model is shown the build log and the failing cases and asked to repair it, for up to 100 rounds.

Every model turn is one row, including the ones that went nowhere.

What is in it

rows (model turns)	1,284
sessions	30
turns carrying a reward	1,211 (94%)
turns marked is_repeat	0 (0%)
turns marked is_repeat_answer	165 (13%)
turns with delimited reasoning	1,129 (88%)
turns whose reasoning has no recorded end	155 (12%)
turns with no reasoning	0 (0%)
reasoning characters	3,595,781
turns cut off by the token cap	0 (0%)
sessions solved outright	18
generated tokens	4,339,239
prompt tokens	19,003,243

0 sessions were excluded: they failed to reach the model at all, so they record an outage rather than an attempt.

Fields

messages and completion are the request as sent and the reply as returned.

Reasoning

The model was asked to work each step out between <think> and </think> before answering. Three fields carry the result:

• text is the training target: the reasoning and the answer in one string, with the tags in place. Stripping the tags returns content exactly.
• thought is the reasoning alone, content the answer alone, for consumers that would rather not parse.
• reasoning says which of those exist, and takes three values rather than the usual two:

value	meaning	text has tags
on	reasoning found, and its end is recorded	yes
unsegmented	reasoning present, but the reply was cut off before it could
close the block, so where it ends is not known	no
off	the model emitted no reasoning	no

unsegmented exists because inventing a boundary would be guessing. Filter on reasoning == "on" for rows whose split is certain.

truncated marks a reply that hit the token cap. The endpoint reports finish_reason: "stop" even when it truncates, so this is derived from the token count instead, and it is the usual cause of unsegmented.

The per-turn outcome fields are the point of this dataset. A turn that produced a program is matched to the iteration its own output was graded as, so:

• reward is what this turn's program scored, not the session's final score
• reward_delta is the change it caused against the previous graded program
• build_ok / build_stage say whether it compiled, and where it failed if not

Labelling every turn with the session's final reward would give the turn that fixed the program and the eighty that did not the same target. These fields exist so that does not have to happen.

is_repeat marks a completion byte-identical to an earlier one in the same session. Inside a long repair loop the model often converges and re-emits the same program for dozens of rounds. Those rows are kept rather than dropped: a model that repeats itself after being shown its failures is a signal about the repair loop, and removing the evidence would hide it. Filter on this field if you want them gone.

record_id identifies the task. Group rows by it to compare attempts at the same task against each other.

The system prompt is identical on every turn and is stored once in system.md, referenced from each row by SHA-256, because inlining 15 KB into every row adds hundreds of megabytes of the same bytes.

Known limitations

One attempt per task. Group-relative methods compare several independent attempts at the same task against each other. This data has one attempt per record, so those groups cannot be formed from it. A second pass over the task set would be needed.

Dominated by repair turns. Roughly 95% of rows are repair turns, and most sessions that run to the 100-round cap never solve. The distribution is therefore heavily weighted towards failure and towards long, low-yield repair chains.

Repetition. See is_repeat above; it is a large fraction of the rows.

Rewards are relative to model-written tests. The tests are frozen before the program is written, but they were written by the same model, so a reward of 1.0 means the program satisfied its own specification, not that it is correct.

Provenance

Generated with nvidia/diffusiongemma-26B-A4B-it-NVFP4, a Gemma-based model. Tasks are derived from gdiamos/classic-eda.

The model's weights are under Apache 2.0 with use governed by the Gemma Terms of Use and the Gemma Prohibited Use Policy. Those terms state that "Google claims no rights in Outputs you generate using Gemma" and that "Outputs are not deemed Model Derivatives" -- so this dataset is not a Model Derivative, and neither is a model trained on it.