Dev.to AI πŸ€– Ai πŸ‘ 0 πŸ“– 6 min read

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

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/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.

Benchmark comparison of MegaBit-trajectories with 5 others from frontier labs

Where MegaBit loses, it says so in the open:

  1. Size: 66 sessions against 59,136 tasks and 702,062 edit pairs.
  2. Repos: Just 5 against 222.
  3. Longest error into retry chain: 4 against 64.
  4. 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.

  1. Use every session. All 66 are full sessions, not answers.
  2. Pack whole sessions. Keep the order. Do not shuffle messages inside a session.
  3. Keep tool results as they are. Cap markers are part of the record.
  4. 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 has role, 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:

  1. Train on it and send the number. Send it to [email protected]. Public results will be linked on the HF page.
  2. 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.
  3. 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.

πŸ“° Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.