What arrives, and in what container

The package

A delivery is a directory, and its name is the first check you can run on it. The identifier reads FHD, then the date, then eight hexadecimal characters lifted from a SHA-256 over the sorted listing of every other file inside, each path paired with its own hash. Rebuild that listing and you have tested whether the package is the package we named.

Inside sit one folder per Clip holding that Clip's export, a compliance log, and a manifest listing every file with its byte size and its SHA-256. The manifest is the one file the package hash does not cover, because a file cannot hold its own hash.

The compliance log carries, for each Clip, the content hash, the consent receipt identifier, the status that receipt held at the moment of packaging, the QA verdict with any rejection reasons, the source of the caption, and whether a redacted video went in.

Assembly refuses rather than skips, and every refusal names what caused it. Five conditions stop a build:

The record of what shipped is append-only. A database trigger refuses an update and refuses a delete, so a later stage — or a contributor who has not read the file — cannot quietly edit the record of what shipped into a record of something else.

The assembly itself is driven end to end against real artifacts by twenty-one checks: the successful build, a tampered file caught, a retired container refused, a Clip with no exported annotation refused, a withdrawal after the release was cut stopping the delivery, the boundary that answers another lab with a 404 rather than a 403, and both triggers.

Two of the five conditions above are not driven by any check yet, and it is worth saying which. When a consent receipt is revoked the release itself stops verifying intact, so that is the refusal that fires; the per-Clip re-check standing behind it is a second line nothing exercises. Nor does anything yet drive the refusal of an export that fails its own reader.

• A release that does not verify intact
• A Clip whose consent receipt is not active at packaging time, even when the release was frozen before the withdrawal
• A Clip with no exported annotation
• A container outside the published set
• An export that its own reader finds broken

The containers we ship, and the two we refuse

Shipped today: LeRobot v2.1 · HDF5 · FH-Ego v1 JSON. On request: Zarr v2 · TFRecord. Not offered: MCAP · WebDataset.

Five containers have a writer here. Three we offer as standard. LeRobot v2.1 writes Parquet, MP4 and JSONL, and our code writes it without the lerobot package. HDF5 follows the paired layout Apple's EgoDex uses, one HDF5 file beside one video. FH-Ego v1 is the video-and-JSON pair our pipeline emits natively.

Two more we produce on request. Zarr v2 uses the UMI and diffusion-policy layout, hand-written because a Zarr v2 store is plain JSON beside raw chunk files. TFRecord carries an RLDS-style step schema, framed by hand, with no TensorFlow anywhere in the path.

Two we refuse, and the reason is the format rather than the effort. MCAP belongs to the ROS 2 and Foxglove logging lineage. We write the record, not a log. WebDataset describes how shards are laid out for a training loop; we hand over the record and leave the sharding to the run that consumes it.

One version distinction, stated plainly because the number matters: we write LeRobot v2.1. We do not write v3.

The LeRobot export carries no action column. This is footage of a person working, and it holds no robot actions; retargeting a human state into a robot action is the lab's modelling decision, so the export documents the absence rather than filling it. The TFRecord export states its own caveat in the same way: it does not load through tfds.load without a dataset builder.

Every row carries the timestamp the pipeline actually sampled, at the rate it actually sampled. No value is interpolated into a frame we did not measure.

• Offered — LeRobot v2.1 (Parquet, MP4, JSONL)
• Offered — HDF5, EgoDex-style paired HDF5 and MP4
• Offered — FH-Ego v1 (MP4 and JSON), what our pipeline emits natively
• On request — Zarr v2, UMI and diffusion-policy layout
• On request — TFRecord, RLDS-style step schema
• Refused — MCAP, a logging container from the ROS 2 and Foxglove lineage
• Refused — WebDataset, a sharding layout that belongs to the training run

The integrity check

Every export is read back off disk before it ships, by a checker that is a separate function from the writer, so nothing leaves on the writer's word for it. What that proves is not the same for all five, and the difference is worth stating rather than averaging away.

The Zarr store is decoded from its own metadata and its raw chunk bytes, with no Zarr package present on either side. The TFRecord is re-framed record by record and its protobuf walked by hand, with no TensorFlow in the path — though its checker computes checksums with the same helper the writer used, so a mistake in that arithmetic would be invisible to it. The LeRobot Parquet is read back through pyarrow and the HDF5 through h5py, the same libraries that wrote them: that catches a damaged file, and it would not catch a mistake inside the library itself. The FH-Ego check reloads the JSON and asserts the action list and the track blocks are present, which is a structural read and nothing more.

Four of the five are proved against deliberate damage: a truncated Parquet, a shortened Zarr chunk, a flipped byte inside a TFRecord record, and garbage written over the HDF5. Each one is caught, and the Parquet case is confirmed to pass again once the file is restored. The fifth, the FH-Ego structural read, has no corruption case yet.

Fifty-three checks cover the five containers: the registry, the folding of samples into steps, a write-and-read-back for each container over our validated recording, the five corruption cases above, the honesty notes carried in each manifest, and the bench's own HTTP surface. Not all fifty-three run a writer — six read the registry alone and six more test the endpoint. An admin route runs the writer and checker pairs on demand; a person runs it, and nothing runs it on a schedule.

Ask us to verify a delivery and we re-hash our own copy, file by file, against the recorded package hash. The answer is one of three words: verified, altered, or missing, and an altered package reports as altered rather than being repaired quietly. That check reads our disk, not yours. The check on the copy you hold is the package name itself — rebuild the listing and compare the eight characters.

When bytes move, they move over a pre-signed URL our own code computes: AWS Signature Version 4, written in the standard library, with the host, the object key and an expiry inside the signature. Where the storage credentials are absent the endpoint answers 503 and names each variable it is missing. It returns no URL in their place. The implementation before this one returned a URL whose signature was a constant string.

Three offline checks pin that arithmetic to the worked example AWS publishes, byte for byte; nine more cover the refusal and the download endpoint. The run against a live bucket is owed and has not happened. No package has yet moved over one of these links.

The sample package

There is no sample package to download, and the chain of reasons is short. A package is cut from a release. A release is cut from Clips. Clips come from a Recording made against a commissioned brief. No lab has commissioned one, so nothing has been cut from captured work, and there is nothing here to hand you.

One recording has been annotated end to end, and its complete annotation is published with its SHA-256 on the reference implementation. Fetch reference-run.json, hash it yourself, and compare. That file is what the FH-Ego v1 container holds for a single Clip; a delivery wraps the manifest, the compliance log and the per-file hashes around it.

That recording predates the consent flow now deployed, and the published file says so about itself: its consent receipt field is empty. Assembly refuses a Clip whose receipt is not active, which means the one artifact we can show you is the one artifact this page's own rules would not package. Recording a Clip through the deployed flow is the next thing we do.

Before a package appears here, a lab commissions a brief, a Capture Partner cohort records against it under the deployed consent flow, the Recording is cut into Clips and each is judged, a release is frozen over them, and the assembly above runs for real. When that happens, this section holds a package and its hash.

What is not offered

Everything above describes what we build. This is the boundary around it.

We deliver nothing by email, FTP, S3 push or webhook. The engine exposes one webhook and it receives payout callbacks, moving no data; no payment provider is connected to it, and it answers 503 until one is. We build a new mode when a paying lab names one.

We write no MCAP and no WebDataset. The reasons sit above, and this is the page that carries them — other pages that name the two formats link here rather than restating the case.

LeRobot v3 has no writer here.

For what sits inside those containers, field by field: FH-Ego v1, field by field.

The exporter offers no custom field set. It emits one schema, FH-Ego v1, and every container above renders that schema.

This page quotes no price. A brief is scoped as one engagement, and the catalogue is where that starts.

We hold no third-party attestation.

We make no claim about what anyone else delivers. Everything above describes files this repository writes and reads back, and you can run the readers yourself.