Verified Coding-Agent Trajectories Built on a Potato PC, and the Comparison Where I Lose

Most training data for coding agents is either scraped final code or synthetic sessions where the model pretends to run commands and invents the output. Both teach the answer. Neither teaches the loop.
I built a small corpus that teaches the loop, and I verified every row of it. Then I compared it against four bigger datasets and published the rows where I lose. This post is the data, the method, and the honest table.
What is in the box
66 full executed sessions. An agent gets a ticket from a real open source commit, works inside a real Docker sandbox, calls real tools, hits real errors, and recovers. Every tool output is stored exactly as the tool produced it, including the failures. Over a million tokens, and nearly every token is a real action or a real observation.
Three guarantees make it usable:
- Real execution only. Exit codes, stderr, durations, real tracebacks. Nothing invented.
- The answer was not in the room. The workspace history is wiped to a fresh root commit, so the agent cannot git log the human fix. The tests are locked so it cannot edit them to cheat.
- Verified, not asserted. A session ships only if the project tests pass and the produced diff clears a similarity gate against the real human patch. An offline verifier re-checks all 66 files on your machine.
Failures are kept in order, not filtered. 60 failed tool runs and the retries that fixed them are part of the data, because the recovery is the lesson.
The honest table
One row means different things in each dataset, so read the unit first. Mine is a session. SWE-smith and SWE-Gym are tasks. ToolACE is a dialogue. CommitPackFT is an edit pair with no process.
Recovery pairs per 10k is a metric I invented: a real error followed by a real corrective action, per 10k tokens. I computed it for everyone including me.
Where I lose, in the open
SWE-Gym beats me on my own metric, 10.72 to 6.48. SWE-smith beats me on longest retry chain, 64 to 4. I lose on scale, on repo count, on published training evidence, and on contamination, because my gold patch is a public commit so this is training food, not a clean benchmark.
I publish those because a table where I win every row is marketing. A table where I lose these rows is measurement. If I hid the losses, you should not trust the wins either.
What I win is the trust layer: an offline verifier, a hash per row, a license and commit per row, split labels with reasons, and the highest density of real calls and real retries per token. Those are the rows that let you check the other rows.
Built on free infra and an i3
No GPU cluster, no paid API budget, no team. One founder, an i3 with 8GB of RAM, free tiers, and free Kaggle GPUs for the training checks. Every session ran in a real sandbox on that machine.
I trained a small model on it to check. One protocol score went from 43% to 80%. Other scores regressed because of MY ENGINEERING ISSUES, so I rebuilt the corpus and I am retraining. No clean win yet, and I am not claiming one. That sentence is in the README too.
Imagine the same method with real compute. The trust rows stay won. The scale row stops being a loss.
Limits, stated plainly
Python only, five libraries. Actions and observations, not captured reasoning, IN THIS VERSION. Small. It is a strong component in a pretraining mixture, not a corpus to train on alone.
Get it and check it
Live now on GitHub and Kaggle. The Hugging Face dataset page lands in a few days.
GitHub: https://github.com/Sumama-Jameel/megabit-trajectories
Kaggle: https://www.kaggle.com/datasets/sumamadev/megabit-trajectories
git clone https://github.com/Sumama-Jameel/megabit-trajectories.git cd megabit-trajectories python3 verify.py If it prints 66/66, you have exactly what I published, byte for byte. Samples ship in OpenAI chat format with converters for other formats included.
What I want from you
Train on it. Report the numbers, including the bad ones. Especially the bad ones. Open an issue with the episode id if something breaks. That feedback is worth more to me than a paywall right now.
The data is MIT, free, no signup. The method is checkable. The losses are published. That is the whole pitch.