Turn robot logs into training sets you can trust.
Traceplane validates, repairs, curates, and versions LeRobot, HDF5, and rosbag2/MCAP data before training. Build reproducible training and evaluation sets with lineage back to every source episode.
# pip install traceplane
# 1. Find what's broken
$ traceplane check ./my-dataset
Result: FAIL — 3 errors, 5 warnings
[X] STATS_NAN_INF — stats['action']['std'][4] is nan
[X] DATA_ZERO_BYTE — 2 zero-byte Parquet files
# 2. Fix automatically
$ traceplane fix ./my-dataset --all
[*] Deleted 2 zero-byte files
[*] Regenerated stats for 5 columns
# 3. Score episodes, salvage good segments
$ traceplane curate ./my-dataset --html report.html
Keep: 1,847 Review: 412 Drop: 139
# 4. Find coverage gaps
$ traceplane coverage ./dataset-a ./dataset-b
[!!!] Severe task imbalance: 'pick' has 800 but 'pour' has 12
[!!!] Action space coverage: 0.2% — collect more diverse demos
# 5. Publish with QA report
$ traceplane publish ./my-dataset --repo-id my-lab/clean-dataset --push
Which episodes are broken.
Which belong in the next training run.
What to collect next.
Your robot data has bugs you don't know about
We audited 10 popular open-source robot datasets. Every single one had quality issues that silently degrade training. Read the full audit.
Metadata lies
Bridge V2 claims 60K trajectories but has 25K. Action space descriptions in features.json are wrong. Your normalization is silently broken.
NaN in your stats
Zero-variance dimensions produce Inf during normalization. NaN propagates through your policy. Training loss looks fine until eval crashes.
Corrupt files ship
Zero-byte Parquet files, missing camera views, timestamp drift between sensors. Nobody catches these at release time. Downstream users lose weeks debugging.
No standard QA tooling
How do you know a dataset is training-ready? There's no pytest for datasets, no CI pipeline for trajectory data, no way to produce a defensible quality report for a paper.
Real output on a real public dataset
Every dataset we score gets a public certification badge. Here's what traceplane cert emits for a live LeRobot dataset on the Hugging Face Hub.
# pip install traceplane
$ traceplane cert hf://datasets/OOJU/wild-mani-kitchen
# ---- Result ---------------------------------------------
Dataset : OOJU/wild-mani-kitchen
Score : 98/100 Grade : A
Badge : https://cert.traceplane.ai/OOJU/wild-mani-kitchen.svg
# ---- Findings -------------------------------------------
warn META_NO_ROBOT_TYPE
meta/info.json is missing "robot_type"
fix: add "robot_type": "<your embodiment>" to meta/info.json
warn META_NO_FEATURES
meta/info.json is missing the "features" block
fix: run `traceplane fix --regen-features` to derive from data/
# ---- Next steps -----------------------------------------
[*] Resolve 2 warnings to reach 100/100
[*] Embed the badge in your README to publish the score
Every dataset gets a public certification badge at cert.traceplane.ai — score, grade, and one-line diffs to reach 100.
Five steps, one CLI
Connect
Point Traceplane at your logs — LeRobot v2/v3, HDF5, rosbag2/MCAP, or a Hugging Face dataset URL. No SDK to embed.
Validate
Structural + statistical + semantic QA. Score every episode 0-100. Fail bad ones before they enter a training run.
Curate
Separate keepers from noise. Score-based drop/review/keep, plus VLM-based semantic gap detection.
Build
Materialize a reproducible train/eval split with real↔synthetic lineage. Export as LeRobot v3 Parquet + MP4, raw Parquet, Arrow, or publish to Hugging Face.
Trace
Every produced dataset carries lineage back to source episodes. Retrace what went into any training run, months later.
Between your robot logs and your training pipeline
Observability tools help teams inspect what happened on a robot. Traceplane governs which experiences become training data and preserves their lineage through evaluation.
Live capabilities
Everything below is shipped today in traceplane 0.5.7 and app.traceplane.ai. Design-partner-only features are called out separately below.
Dataset certification with public badge
Every dataset scores 0-100 across structural, statistical, and semantic layers. A Codecov-style SVG lives at cert.traceplane.ai/{org}/{name}.svg — embed it in a README and readers see the grade at a glance.
Ingest any format
LeRobot v2/v3 (JSONL or Parquet metadata, chunked shards), HDF5 (robomimic / ActionNet), and rosbag2 (.mcap/.db3). Everything normalizes to a canonical episode schema.
50+ QA checks
Structural (schema, dims, video decodability), statistical (NaN stats, zero-variance columns, ML outliers, near-duplicates), and semantic (annotation coverage, missing language, low object diversity). CI-friendly — exits non-zero on failure.
VLM auto-annotation
Send keyframes to a vision-language model, get structured per-episode task sentence, objects with action verbs, scene description, and success guess. Merge-upsert into meta/annotations.jsonl. Powers the semantic QA layer.
Real↔synthetic lineage + eval guard
Auto-stamp episodes as real, simulated, augmented, or mixed on import. Splits force synthetic episodes into train, never eval — no silent benchmark contamination. Mix compiler shows a lineage breakdown for every recipe.
Episode curation scoring
Score every episode on smoothness (jerk), outlier distance from the dataset centroid, and uniqueness (k-NN over embeddings). Keep / review / drop recommendations with visual HTML reports.
Versioning: snapshots + branches
Immutable point-in-time snapshots with parent tracking and diffable episode lists. Named branches on top of the snapshot history — fork, switch, delete. Reproduce any training run months later.
SQL engine with trajectory UDFs
DataFusion 52 over Arrow, with vector UDFs (vec_mean, vec_norm, vec_cosine_sim, and eight more) for trajectory-aware queries. Every workspace gets its own engine — no shared context across orgs.
Materialize & publish
Export SQL results to Parquet or Arrow. Round-trip to LeRobot v3 Parquet + MP4. One command to push to Hugging Face Hub with auto-generated dataset card and QA stats.
Multi-tenant isolation
Per-org DataFusion engine, per-org LanceDB namespace, org-scoped S3 prefixes. The API never accepts a caller-supplied path verbatim — every request is validated against the caller's own scope.
Embodiment registry
Eight built-in robot profiles (Franka, ALOHA v2, Unitree G1/H1, UR5e, KUKA iiwa, xArm 7, Stretch 3). One YAML drives Rust + Python — joint groups, limits, and action-space validation stay consistent across the stack.
Full XR retargeting
Calibrate XR world frame ↔ robot base frame; retarget human hand poses to end-effector actions. Today the platform ships a bridge for recorded calibrations — live XR pipelines are a design-partner engagement.
Per-frame VLM annotations
The shipped VLM path emits one structured annotation per episode. Per-frame semantics — dense captions, temporal grounding, action-boundary labels — is a design-partner build.
Custom compliance rules
Add org-specific QA gates on top of the 50+ built-ins — PII redaction checks, embodiment-specific joint-limit rules, custom taxonomy conformance. We wire these directly into your ingest.
Per-org compute isolation
Dedicated compute for QA, curation, and VLM annotation runs — no shared workers, no queue contention. Sized to your dataset volume.
Private-cloud deployment
Ship the platform into your VPC or on-prem cluster. On the roadmap for enterprise design partners — bring the requirement, we'll scope the deployment.
Three ways teams use Traceplane
Pre-training gate
Run traceplane check as a CI hook on every dataset PR before it merges. Catches broken stats, corrupt files, and schema drift before a $10k training run wastes GPU time.
Catch broken data before your GPUs do.
Fleet failure curation
Deployed robots log every intervention and edge case. Traceplane curates the interesting subset — novel scenes, unexpected object interactions, near-failures — and produces a versioned training set for the next fine-tune.
One week of logs → the next training run.
Dataset publishing
Research lab wants to publish a LeRobot dataset. Traceplane validates it, fixes fixable issues, produces the cert badge, and ships to Hugging Face with a link back.
Publish datasets that carry a public quality signal.
Open-source CLI, hosted platform
pip install traceplane
QA, cert badge, fix suggester, curation, and publish — all run locally. No account needed. This is the free tier of the wedge.
app.traceplane.ai
Multi-tenant catalog, dataset browsing, per-org isolation, VLM annotations, and versioning. Currently available to design partners. Private deployment options are on the roadmap for enterprise design partners.
Bring one dataset or one week of robot logs.
We will identify unusable and valuable episodes, produce a versioned training set, and measure the time saved.
Request accessFrequently asked questions
What data formats does Traceplane support?
Traceplane ingests LeRobot v2/v3, HDF5 (robomimic/ActionNet style), and rosbag2 (.mcap/.db3). All data is normalized to a canonical episode schema and can be exported as LeRobot v3 Parquet + MP4, raw Parquet, Arrow IPC, or published to the Hugging Face Hub.
How does automated QA work for robot trajectory data?
Every episode is scored across three layers: structural checks (schema conformance, FPS consistency, stats sanity, metadata completeness), ML-based outlier detection (embedding-space distance from peers), and VLM-based semantic checks (language instruction presence, object diversity, coverage gaps). Findings resolve to a 0-100 cert score with a public badge URL.
What is embodiment-aware storage?
Traceplane understands the physical meaning of each data dimension — for example, which joints belong to a 7-DoF left arm vs. a 3-DoF waist. This lets you store data from a 23-DoF humanoid and query just the arm joints, or search across different robot embodiments for similar tasks.
How is Traceplane different from observability tools like Foxglove or Rerun?
Observability tools help teams inspect what happened on a robot. Traceplane sits one layer up: it governs which episodes become training data, runs QA gates before they enter a training run, and preserves lineage from source episode through evaluation. You can visualize with Rerun or Foxglove and still use Traceplane as the dataset CI in front of your training pipeline.
Does Traceplane support human demonstration data from XR/wearables?
Traceplane ingests LeRobot-formatted human-demo datasets (e.g., wearable or teleop captures exported to LeRobot v2/v3) and runs the same structural + statistical + semantic QA over them. Full XR retargeting and wearable-specific QA rules aren't in the shipped platform yet — those are on the roadmap. Today we're the QA + versioning + certification layer over your existing capture stack.
Can I stream data directly into my training loop?
Yes. Traceplane provides streaming dataloaders for PyTorch and JAX that serve Arrow batches directly — no need to download terabytes to local disk first. You can also resample on the fly, for example data stored at 30Hz served at 10Hz.
Who is behind Traceplane?
Traceplane is built by engineers with deep experience in robotics data pipelines and large-scale ML infrastructure. We've worked with rosbag2, LeRobot, HDF5, and custom formats across humanoid manipulation, mobile robotics, and simulation — and built Traceplane to solve the data problems we kept hitting ourselves.
Is my data secure?
Yes. Each organization has an isolated query engine and org-scoped object storage paths, with no cross-tenant access at the query layer. Data is encrypted in transit (TLS) and at rest. We never use your data to train models or share it with other customers.
Get a free dataset audit
Send us your dataset (or a link) and we'll run our full QA pipeline on it. You'll get a detailed report of every issue we find — no commitment required.