Startups

Pretraining Data for Robotics Startups

A robot-foundation-model startup needs pretraining-stage data before it can run a single mid-training or fine-tuning batch, but an early-stage team rarely has the headcount or rig fleet to capture that scale itself, and public pretraining corpora were built for someone else’s task distribution and often ship research-only terms. Custom egocentric pretraining data lets a small team start from a written spec, prove it on a small Spec Pilot batch, and scale only once the pilot has shown the spec, labels, and formats fit the training pipeline.
Starting point
Written skill spec, any size
First commitment
Small Spec Pilot batch
First batch
Median 48 h
License
Perpetual, buyer-owned
A contributor wearing a head-mounted capture rig performs a manual task, beside a graphic of synchronized hand-pose, depth, and action-segment annotation layers.
A startup pretraining collection starts with a written spec, proves it on a Spec Pilot batch, and scales from there.

Why a startup needs this

Why does a robotics startup need custom pretraining data instead of a public corpus?

01

Coverage scoped to your roadmap, not someone else’s

Public pretraining corpora were captured for the task distribution and objects their own authors cared about. A custom spec scopes tasks, environments, and regions to the specific gap your model needs filled next.

02

A license that actually clears commercial training

Many large public egocentric corpora carry non-commercial or research-only terms. A custom collection ships under a perpetual, buyer-owned commercial license backed by a documented consent chain, from the outset.

03

A small first commitment, proven before you scale

A Spec Pilot is a small, fast first batch that proves stream quality, hand-pose and action-label fidelity, and format compatibility before a startup commits to full-volume pretraining data.

04

Formats that drop straight into existing pipelines

RLDS, LeRobot, WebDataset, HDF5, zarr, and Rerun .rrd, so a startup does not need a separate ingestion pipeline for pretraining data versus the mid-training and fine-tuning data it collects later.

Definition

What pretraining data does a robotics startup need?

A robotics startup building or fine-tuning a robot foundation model needs the same base-layer data any foundation model needs: broad, first-person coverage of human behavior across tasks, objects, and environments, captured with manipulation-grade signal — hand pose, depth, and action labels — rather than raw RGB alone.

What differs for a startup is scale and commitment. A written spec can be sized to an early program’s actual roadmap — a focused set of tasks and environments — rather than requiring the budget or volume a larger lab would commit to on day one.

Public vs custom

Why can’t a startup rely only on public pretraining corpora?

Public egocentric corpora are a legitimate way to build broad, general priors — EgoScale’s own results show a research-grade corpus, action-labeled by off-the-shelf SLAM and hand-pose estimation, is enough to demonstrate a real scaling law and a measurable success-rate gain. The limitation for a startup is coverage and licensing, not whether scale is achievable at all.

A public corpus was captured for someone else’s task distribution, so it is always missing exactly what a given model needs next, and most large egocentric corpora carry non-commercial or research-only terms rather than a right to train a commercial product on them. A custom collection closes both gaps: coverage scoped to the exact tasks and environments a startup’s model is missing, and a license written for commercial training from the outset.

Training stages

How is pretraining data different from mid-training and post-training data?

Per NVIDIA’s GR00T N1 data pyramid, pretraining sits at the base: web data and human video, because they are the most abundant. Mid-training sits above that with more targeted, aligned data, and real robot trajectories sit at the top because they are scarcest and most expensive. A pretraining-stage purchase is judged on breadth across tasks, objects, and environments — not on how closely it matches a single target robot embodiment.

A startup working through all three stages does not need a separate data provider or ingestion pipeline for each: the same ten-stream capture stack and delivery formats (RLDS, LeRobot, WebDataset, HDF5, zarr, Rerun .rrd) carry across pretraining, mid-training, and fine-tuning data.

Scoping

How should a startup scope its first pretraining collection?

Start from the gap in your model’s current coverage rather than a target hour count: which tasks, objects, or environments is the model still weak on. That becomes a written spec covering tasks, environments, regions, capture tier, annotation depth, and accept criteria, quoted for reach, timeline, and price before any capture begins.

Because the spec drives both coverage and cost, a startup can start narrow — a handful of tasks and environments — and widen the spec once the pilot has proven out quality and format fit, rather than committing to broad coverage before knowing whether the pipeline integration works.

Diversity vs volume

Why does diversity and label quality matter more than raw hours?

Generalist AI’s GEN-0 program, at 270,000+ hours and growing by 10,000+ hours per week, states explicitly that data quality and diversity matter more than sheer volume. For a startup with a limited budget, that means a smaller, more diverse, well-labeled corpus scoped to the model’s actual weak spots is a better pretraining investment than maximizing hour count alone.

Every episode in a custom collection ships with hand pose, depth, and action labels captured live on the rig rather than estimated from raw video afterward, so the manipulation-grade signal that generalization research points to is present from the first batch, not added later.

Capture

Which capture setup and labels does a startup receive?

Ten synchronized streams per episode: 4K head camera, two wrist cameras, depth, IMU, 3D hand and body pose, instance segmentation, and action labels, hardware-aligned under 2 ms. Nothing in this stack is estimated after capture — pose and action labels come from the rig and the capture pipeline, not a post-hoc annotation pass on raw RGB.

Coverage (tasks, environments, regions) is set by the written spec a startup provides, not a fixed catalog of available footage, so the corpus fills the specific gap the model needs rather than being generally useful to everyone.

Consent and licensing

How are consent, anonymization, and the buyer-owned license handled?

Every episode links to a signed contributor release through a documented consent chain. Faces, plates, and screens are detected and irreversibly blurred at ingest, and a reviewer confirms the result before anything ships, with the anonymization record delivered alongside the data.

Delivered data carries a perpetual, buyer-owned commercial license, with exclusivity available so the same data is never resold to a competitor — the licensing clarity many public pretraining corpora do not provide for commercial use.

Getting started

How does a startup start with a Spec Pilot and scale in batches?

Many programs, including early-stage teams, start with a Spec Pilot: a small, fast first batch that proves the spec and accept criteria before committing to scale. It lets a startup check stream quality, hand-pose and action-label fidelity, and format compatibility with its own training pipeline before volume ramps.

From there, the purchase scales through the same seven-stage pipeline used for every Firsthand program — contributor recruiting, capture, per-batch QA, anonymization, and licensed delivery — with rejected items recaptured at Firsthand’s cost. A median 48-hour turnaround on a first batch means a startup can validate the spec quickly, then scale to the volume its model needs, with on-demand top-ups available afterward as new gaps show up during training.

At a glance

What you get.

Purchase model
Written spec, quote, Spec Pilot, scale
Streams
Ten, synced under 2 ms
Billing
Per validated hour
First batch
Median 48 h
Pilot option
Spec Pilot before scaling
License
Perpetual, buyer-owned

Every collection runs through the same seven-stage end-to-end custom collection pipeline. End-to-end custom data collection is a managed service that takes an AI data need from problem to owned dataset in a single accountable pipeline.

Training stages

Where does pretraining data fit against mid-training and post-training?

How a startup’s pretraining-stage purchase differs from mid-training and post-training data, per the GR00T N1 data pyramid.
StageGoalData typeWhere custom collection fits
PretrainingBroad visual-motor priors before touching a target robotWeb data and first-person human video (most abundant)Custom egocentric collection scoped to a written spec, closing public-corpus coverage and license gaps
Mid-trainingAligning priors toward a narrower task or embodiment familyMore targeted, aligned dataSame capture stack and formats, narrower spec
Post-training / fine-tuningAdapting to a specific target robotReal robot trajectories (scarcest, most expensive)Outside the scope of this egocentric pretraining page

Public vs custom

Public pretraining corpora vs a custom startup collection

Reference points from the public corpora cited on this site, compared with a custom Firsthand pretraining purchase.
CorpusHours (as reported)LicenseLabels / diversity control
EgoScale20,854 hours, action-labeled egocentric human videoNot stated in the paperLabels from off-the-shelf SLAM and hand-pose estimation
GEN-0 (Generalist)270,000+ hours; 10,000+ new hours per weekNot publishedStates diversity and quality matter more than volume
EgoVerseRoughly 1,362 hours across ~80,000 episodesNot stated in the paperEgocentric video corpus
Egocentric-10K10,000 hoursApache 2.0Egocentric video corpus
Custom Firsthand purchaseScoped to your written spec, no fixed corpus sizePerpetual, buyer-owned, commercialHand/body pose and action labels captured live on the rig; diversity controlled by the spec

FAQ

Pretraining data for robotics startups, answered.

Can an early-stage startup afford custom pretraining data?
There is no fixed price list — cost is quoted against a written spec, and a startup can scope that spec narrowly to its current roadmap. Many programs start with a small Spec Pilot batch rather than a full-volume commitment, so a startup can validate quality and fit before scaling spend.
How is this different from the general startup data page?
This page is specifically about pretraining-stage data — the broad, base-layer priors a robot foundation model needs before mid-training or fine-tuning. The general startup page covers custom egocentric data collection more broadly, across any stage of a startup’s training pipeline.
Why not just use a free public egocentric pretraining corpus?
Public corpora like EgoScale and Egocentric-10K are useful for building broad, general priors, but they were captured for someone else’s task distribution and often ship research-only or unstated licensing terms. A custom collection is scoped to the exact tasks and environments a startup’s model is missing, under a license written for commercial training.
What is a Spec Pilot and why does it matter for a startup?
A Spec Pilot is a small, fast first batch captured against a written spec before any commitment to scale. It lets a startup check stream quality, hand-pose and action-label fidelity, and format compatibility with its own training pipeline before a larger purchase.
What streams and labels are included in a pretraining batch?
Ten synchronized streams per episode — 4K head camera, two wrist cameras, depth, IMU, 3D hand and body pose, instance segmentation, and action labels — hardware-aligned under 2 ms.
Who owns the data once a startup purchases it?
The buyer does. Delivered data carries a perpetual, buyer-owned commercial license backed by a documented consent chain, with exclusivity available so the same data is never resold to a competitor.
How fast can a startup get a first validated batch?
A median of 48 hours for a first validated batch where coverage is already deep for the spec’s tasks and environments; longer where coverage is thin and new contributor recruiting is required.
What formats does the data ship in?
RLDS, LeRobot, and WebDataset, plus HDF5, zarr, and Rerun .rrd, with readable converter source so a startup can retarget the schema to its own training pipeline.

Sources

Where are these pretraining claims documented?

Request a custom pretraining dataset for your startup.

Tell us the tasks, environments, and streams your pretraining corpus is missing. We will quote reach, timeline, and price against a written spec, with a first validated batch in a median of 48 hours.