I'm 14 y/o building a startup, and the first user-facing thing is finally out on Hugging-Face, totally free.
MIT | Sessions | Tool calls | Verified TL;DR This is 66 full coding agent sessions. Real tickets, tool calls AND MAINLY real errors. Real fixes. All verified. All free on Hugging Face. Link: https://huggingface.co
MIT | Sessions | Tool calls | Verified
TL;DR
This is 66 full coding agent sessions. Real tickets, tool calls AND MAINLY real errors. Real fixes. All verified. All free on Hugging Face.
Link: https://huggingface.co/datasets/Sumama-Jameel/megabit-trajectories
Load it in 3 lines. Verify it in 1 command. Train on it today.
What is wrong with most agent data
Most agent data is made up. Or it is cleaned until the hard part is gone.
The model sees a clean question and a clean answer. It never sees the messy middle. It never sees the wrong tool call, the broken test, the bad grep, the retry.
So the model learns the happy path. Then it fails in real work, because real work is not the happy path.
This dataset is built to fix that one thing.
What this dataset is
One row is one full session, in order.
system: the tools, the workspace, the rules
user: the ticket, what to change and how it will be checked
assistant: tool calls, read, grep, edit, write, bash, todo
tool: the exact output, including errors
assistant: the next step
tool: a failing test run
assistant: the fix, the retry, the passing run
Nothing is summarized or made up. The final patch is in the transcript.
Every command ran in a real Docker sandbox. The output is what the tool printed, not a rewritten summary.
The workspace starts from a fresh root commit. Git history cannot hand the model the human fix. The answer was not in the room.
What is in the box
| Item | Value |
|---|---|
| Sessions | 66 |
| Repos | attrs, click, packaging, tenacity, cli |
| Language | Python |
| Tool calls in training rows | 2,312 |
| Tool calls in raw logs | 2,541 |
| Recovered calls | 221 authentic calls from failed attempts |
| Failed tool runs kept with the fix | 61 |
| Parallel call batches | 456 |
| Sessions with tests passing at the end | 66 of 66 |
| Audit checks per session | 4 of 4 |
| Models | 3, recorded per row |
| Size | About 1.17M tokens of message content |
| License | MIT for packaging, upstream licenses kept per row |
The 4 audit checks are ticket path, provenance, license, and tests.
Why failure is the data
| What you get | Why it matters |
|---|---|
| Failed commands kept | Model learns what a real error looks like |
| Rejected calls kept | Model learns what a bad argument looks like |
| Broken tests kept | Model learns what a broken run looks like |
| Retry after fail kept | Model learns how to fix, not just how to answer |
| Malformed call kept | One row keeps a malformed grep call exactly as issued, with parse_status: error. Clean data teaches the happy path. This row teaches the rest |
Key idea: If you delete the failures, you delete the training signal for recovery. Recovery is the skill that makes an agent useful.
How it compares
This is from a direct check against 5 other public datasets, with the same ruler for all 5.
Where MegaBit loses, it says so in the open:
- Size: 66 sessions against 59,136 tasks and 702,062 edit pairs.
- Repos: Just 5 against 222.
- Longest error into retry chain: 4 against 64.
- Published training proof: They have it. This release does not, yet.
A table where one dataset wins every row is marketing. And the table where it loses these rows is measurement.
Load it in 3 lines
from datasets import load_dataset
ds = load_dataset("Sumama-Jameel/megabit-trajectories", split="train")
print(ds[0]["repo"], len(ds[0]["messages"]), "messages")
Verify it yourself
Do not take any number on faith. Run this:
git clone https://huggingface.co/datasets/Sumama-Jameel/megabit-trajectories
cd megabit-trajectories
python3 verify.py
# 66/66 episodes verified
verify.py re computes both sha256 values per session, checks the header and footer, the tool call count, the export verdict, and the provenance fields. It proves the row you downloaded is the row that was published.
- [x] Hashes match
- [x] Tool call counts match
- [x] Provenance fields match
- [x] Verification verdict match
How to train on it
This is continued pretraining data. The supervision is the whole transcript, in order.
- Use every session. All 66 are full sessions, not answers.
- Pack whole sessions. Keep the order. Do not shuffle messages inside a session.
- Keep tool results as they are. Cap markers are part of the record.
- Measure the loop, not just the final answer.
| What to measure | How |
|---|---|
| Tool call schema validity | Are the arguments valid JSON for the schema |
| Parse rate | How many calls parse without error |
| Tests passed at the end | Does the session end green |
| Recovery rate | Does the session fix its own failed call |
For fine tuning
The repo ships a tool that converts this data into the layout your trainer expects.
python3 convert_formats.py --help
It covers OpenAI message format, ShareGPT, Hermes, raw text, and a generic trainer layout that covers LoRA and most fine tuning setups. It includes a check mode, so you can verify that reformatting stayed lossless before you train.
Need a lighter set? Run it with the clean flag and keep only the verified sessions.
Schema, one row
-
episode_id: the stable session id -
id: the record id -
repo,repo_url,license: the upstream repo and its SPDX license -
model: the model that produced the session -
messages: the full ordered transcript. Each message hasrole,content,name,tool_call_id,tool_calls,error,truncated,duration_ms,dropped_chars,original_chars -
tools: the OpenAI function calling catalog used in the session -
metadata: tool count, attempts, review rounds, normalization detail, terminal state -
provenance: repo, base commit, target commit, license, model, session id, task check -
verification: the export verdict and checks -
produced_diff_sha256: the sha256 of the agent diff
Inside tool_calls, arguments is JSON text. Parse it with json.loads(tc["arguments"]). The one malformed call has arguments: null, arguments_raw set, and parse_status: "error", so a strict loader can branch before parsing.
import json
row = ds[0]
for msg in row["messages"]:
for tc in msg["tool_calls"] or []:
if tc["parse_status"] != "error":
args = json.loads(tc["arguments"])
Files in the repo
data/train.parquet the 66 training rows, viewer ready
data/train.jsonl the same rows, one JSON object per line
data/index.parquet one flat row per session, easy to filter
data/index.json the same index as JSON
data/tools.json the tool contract for the whole corpus
episodes/ the full record, raw log, sample, ticket, evidence
verify.py offline integrity check
check_shape.py message shape check
retag_tools.py rename the tool vocabulary
convert_formats.py export to OpenAI, ShareGPT, Hermes, text, or a trainer layout
counts.json the source of truth for every count
DATA_CARD.md the full data card
PILOT.md how to get a private corpus for your lab
TOOLS.md the tooling guide
Long tool outputs in data/ are capped with an explicit marker. The full text is in episodes//.episode.jsonl.
retag_tools.py rewrites the tool vocabulary in one command, with a check mode. Rename there and back and the bytes match.
What to do next
If you use it, do 3 things:
- Train on it and send the number. Send it to [email protected]. Public results will be linked on the HF page.
- Ask for a repo or a language. The engine already handles JS, TS, Go, and Rust. The next release will be what people ask for.
- Open an issue with a session id if something looks off. It will be checked and the release will be improved in the open.
For labs: Want this on your stack
The free dataset is the public proof. The pilot is the private version.
Pilot includes:
- Your repositories
- Your languages. Public release is Python. Pilot covers your stack
- Reasoning traces, if your training recipe needs them
- Your harness, your tools, your tests
- Your eval, run before and after
- A fixed scope, a fixed timeline, and a verifier you keep
If you are at an AI lab and you want a private corpus, email [email protected] with the subject MegaBit pilot. Tell us the model, the repos, the capabilities, and the eval you care about. We will send a scope and a date.
Cite this dataset
@dataset{megabit_trajectories_2026,
title = {MegaBit Trajectories},
author = {Jameel, Sumama},
year = {2026},
publisher = {MegaBit},
url = {https://huggingface.co/datasets/Sumama-Jameel/megabit-trajectories},
license = {MIT}
}
License: MIT for the data packaging. Upstream source code keeps its license. Each row carries license. Upstream notices travel with the data.
Link again: https://huggingface.co/datasets/Sumama-Jameel/megabit-trajectories
Download it. Run verify.py. Train one run. Tell us where the data is wrong. It will be fixed in the open.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.