MIMO Claude Code Traces 1K: A Coding-Agent Trajectory Dataset

MIMO Claude Code Traces 1K is an open-source dataset of Claude Code-style coding-agent trajectories. It contains 1,017 complete traces generated with MiMo-V2.5-Pro, covering user coding tasks, multi-turn messages, tool schemas, assistant reasoning fields, tool calls, tool outputs, and metadata such as model name, category, duration, cost, token usage, and whether tools were used.

The dataset is designed for research around code agents: tool-use imitation, code-agent distillation, supervised fine-tuning, trajectory modeling, reasoning/tool-call alignment, and evaluation of software-engineering behavior.

Why MIMO Claude Code Traces Exists

Modern coding agents are not just code generators. They inspect files, run shell commands, edit code, recover from tool errors, reason over long contexts, and gradually refine a solution across many turns. Training and evaluating this behavior requires more than isolated prompt-response pairs.

MIMO Claude Code Traces narrows this problem into complete agent trajectories collected in a Claude Code-style environment. This setting is useful because software-engineering agents naturally involve:

• multi-turn task decomposition and iterative implementation;
• file reading, editing, searching, and shell execution;
• tool-call planning and recovery from failed commands;
• debugging, refactoring, API integration, and devops workflows;
• long-context reasoning over code, logs, and intermediate observations;
• token, cost, and duration metadata for efficiency-aware analysis.

By preserving full event streams instead of only final answers, the dataset supports research on how code agents actually behave while solving tasks.

Model and Generation Setup

The traces were generated with mimo-v2.5-pro, MiMo’s most capable model at the time of release. MiMo-V2.5-Pro is a 1.02T-parameter Mixture-of-Experts model with 42B active parameters, a hybrid-attention architecture, and a 1M-token context window.

It is designed for agentic workloads, complex software engineering, and long-horizon tasks, with improved instruction following and coherence across ultra-long contexts. In tool-using harnesses, it can sustain complex trajectories spanning hundreds to more than a thousand tool calls.

The dataset was produced in an agentic coding setup with tools such as Bash, Read, Write, Edit, Glob, Grep, TodoWrite, and planning utilities. The dataset construction process used approximately 400M tokens in total, while the released trace metadata records approximately 127.2M logged usage tokens across input, cache-read, and output token fields.

Dataset Overview

Each .jsonl file contains one complete Claude Code-style event stream. The release is organized by task category under session/.

Key Statistics

Logged Usage Tokens

Dataset Structure

The dataset is organized as a top-level README plus category folders. Each category folder contains JSONL traces for one type of coding-agent task.

mimo-claude-code-traces-1k/
├── README.md
└── session/
    ├── algorithms/
    │   └── *.jsonl
    ├── api_integration/
    │   └── *.jsonl
    ├── code_generation/
    │   └── *.jsonl
    ├── data_processing/
    │   └── *.jsonl
    ├── debugging/
    │   └── *.jsonl
    ├── hf_trace/
    │   └── *.jsonl
    ├── math_problems/
    │   └── *.jsonl
    ├── refactoring/
    │   └── *.jsonl
    ├── shell_devops/
    │   └── *.jsonl
    └── supplement/
        └── *.jsonl

Category Distribution

The dataset covers algorithmic tasks, code generation, debugging, refactoring, shell/devops, Hugging Face traces, data processing, and reasoning-heavy coding prompts.

Token and Cost by Category

Tool Use

MIMO Claude Code Traces captures explicit tool-call behavior, including successful calls and tool error messages. This makes it useful for learning when to call tools, how to recover from failed calls, and how to combine shell/file operations with natural-language reasoning.

Available tool schemas are included in every trace. The common Claude Code-style tool inventory includes:

Task, AskUserQuestion, Bash, CronCreate, CronDelete, CronList, Edit,
EnterPlanMode, EnterWorktree, ExitPlanMode, ExitWorktree, Glob, Grep,
NotebookEdit, Read, ScheduleWakeup, Skill, TaskOutput, TaskStop,
TodoWrite, WebFetch, WebSearch, Write

Event Stream Schema

Each .jsonl file in session/<category>/ is one Claude Code-style event stream. Each line is one event.

Common top-level fields include:

Assistant events store Claude-style message content blocks:

Tool outputs are represented as user events whose message.content contains tool_result blocks linked by tool_use_id.

Event-Type Counts

Example Event Lines

{"type":"mode","mode":"normal","sessionId":"7469deea-7e45-4732-8f06-9666d52052d4"}
{"type":"user","message":{"role":"user","content":"Implement Kahn's algorithm for topological sort..."},"sessionId":"7469deea-7e45-4732-8f06-9666d52052d4","uuid":"...","parentUuid":null}
{"type":"assistant","message":{"model":"mimo-v2.5-pro","role":"assistant","content":[{"type":"thinking","thinking":"..."},{"type":"text","text":"Let me explore the codebase."},{"type":"tool_use","id":"call_...","name":"Bash","input":{"command":"ls /data/agent/choucisan"}}]},"sessionId":"7469deea-7e45-4732-8f06-9666d52052d4","uuid":"...","parentUuid":"..."}
{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"call_...","content":"...","is_error":false}]},"sessionId":"7469deea-7e45-4732-8f06-9666d52052d4","uuid":"...","parentUuid":"..."}

Some fields are normalized because the original collected data did not include the full Claude Code runtime envelope. In particular, uuid, parentUuid, requestId, cwd, version, and gitBranch are deterministic conversion fields rather than raw Claude Code runtime fields.

Highlights

• Complete trajectories: Each file contains a full coding-agent event stream, not just a final answer.
• Reasoning fields: All 1,017 traces include assistant reasoning fields.
• Tool-rich behavior: 859 traces include tool calls, with 5,271 assistant tool calls in total.
• Claude Code-style format: Events follow a familiar agent trace shape with assistant, user, tool_use, and tool_result blocks.
• Broad task coverage: Categories include algorithms, debugging, refactoring, shell/devops, API integration, data processing, and math-heavy coding prompts.
• Efficiency metadata: Token usage, duration, and recorded cost fields support cost-aware and latency-aware analysis.
• Recovery behavior: Tool errors, failed edits, missing files, and shell diagnostics are retained for studying agent robustness.

Quick Start

Load the dataset directly from Hugging Face:

from datasets import load_dataset

repo_id = "choucsan/mimo-claude-code-traces-1k"
dataset = load_dataset(repo_id, data_files="session/**/*.jsonl")

print(dataset["train"][0])

Read local JSONL files:

import json
from pathlib import Path

root = Path("mimo-claude-code-traces-1k")
files = sorted((root / "session").glob("*/*.jsonl"))

events = []
for path in files:
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            if line.strip():
                events.append(json.loads(line))

print(len(events))
print(events[0])

Count tool calls:

from collections import Counter

tool_counts = Counter()

for event in events:
    message = event.get("message") or {}
    for block in message.get("content", []) or []:
        if isinstance(block, dict) and block.get("type") == "tool_use":
            tool_counts[block.get("name")] += 1

print(tool_counts.most_common())

Applications

MIMO Claude Code Traces can be used in several research and development settings.

Data Quality Notes

• Each file in session/<category>/ is a Claude Code-style JSONL event stream for one trace.
• All released traces report metadata.model = "mimo-v2.5-pro".
• All 1,017 traces include reasoning fields.
• 859 traces include at least one tool call.
• Tool outputs may include errors, failed edits, missing files, or shell diagnostics; these are retained because they are useful for training recovery behavior.
• The dataset contains generated coding-agent traces, not verified production patches. Users should validate code before using examples as ground truth.
• The event stream is converted from normalized trace records. Some Claude Code envelope fields are deterministic reconstruction fields because the original records did not include raw runtime UUIDs or local harness metadata.
• The recorded token accounting in assistant message.usage reflects logged trace metadata and does not include all tokens used during the broader dataset construction process.

Links

• Hugging Face: huggingface.co/datasets/choucsan/mimo-claude-code-traces-1k

Citation and Contact

If MIMO Claude Code Traces helps your work, please consider linking back to the dataset page. For questions, corrections, or collaboration, contact choucisan@gmail.com.