Deformable objects

Egocentric Deformable Object Manipulation Data

Cloth, bedding and bags change shape as they are handled, and a policy that has to fold, sheet or tie them needs demonstrations that show the hands and the item together, step by step. We capture egocentric deformable object manipulation data on demand: custom first-person video of people doing the deformable tasks this site lists, written into a skill spec, with hand pose, contact events, action segments and synchronized depth and IMU, QA-checked, anonymized and delivered under a buyer-owned license.
Tasks
Laundry, bed-making, bag tie
Structure
Episodes with ordered action segments
First batch
Median 48 h in deep-coverage settings
License
Perpetual, non-exclusive, buyer-owned
A lived-in living room with a worn sofa, mugs on the coffee table and a laundry basket, the kind of home setting where laundry tasks are captured from a first-person viewpoint.
Deformable tasks are captured in the home settings this site already lists, from the hands’ own point of view.

Requirements

What does a deformable task need that a rigid-object task does not?

01

Both hands, in frame, at the same time

Many soft-object tasks depend on what the second hand is doing at the same instant: stabilizing, supporting or handing off. First-person capture keeps both hands and the item in view across the whole attempt.

02

Masks that follow the item every frame

Clothing, bedding and bags do not track well with masks propagated frame to frame the way a rigid object does, so deformable captures ship per-frame instance masks where the spec calls for them.

03

Sub-steps with explicit boundaries

A fold, a sheet change or a bag tie is a short chain of steps. Action segments carry start and end timestamps for each one, so the structure is in the labels rather than left for a model to guess.

04

Hand pose and contact that survive occlusion

Fabric covers fingers. 3D hand pose carries a per-joint visibility flag, and contact events mark when the hand meets the item, so a hidden joint is flagged rather than silently guessed.

Definition

What is egocentric deformable object manipulation data?

Egocentric deformable object manipulation data is first-person video of a person working with an item that changes shape as it is handled, recorded from their own point of view with synchronized sensor streams alongside. On this site the deformable items are clothing, bedding and bags, and the tasks are the laundry, bed-making and bag-handling routines listed below.

This page covers buying a custom collection of those demonstrations. It is narrower than a general dexterous-manipulation collection and than household pretraining at scale: the subject here is the deformable task itself, how it is specified, and how it is labeled so a training pipeline can use it.

Why it is hard

Why are deformable objects hard for robot learning?

A rigid object keeps one shape, so its position and orientation describe it. A towel, a sheet or a bag has no single shape: it folds, drapes and bunches as it is handled, and part of it is usually hidden under the hand. Three consequences show up in the data, and each is something this site already addresses rather than something we add here.

First, tracking. Clothing, bedding and bags do not track well with masks propagated frame to frame, which is why the household datasets here ship per-frame instance masks, at the highest annotation cost per hour in the catalog. Second, occlusion: fingers disappear under fabric, so hand pose needs a per-joint visibility flag. Third, coordination: many soft-object tasks, from opening a jar to folding fabric, depend on what the second hand is doing at the same instant.

We do not capture robot or teleoperation data, and nothing here claims a training outcome. The tradeoff to plan for is the embodiment gap between a human hand and a robot end-effector, which retargeting or pairing with robot data has to close. What you get is human first-person demonstrations in which the hands, the item and the step structure are all explicit.

Tasks

Which deformable tasks can be captured?

The deformable tasks this site already lists are: fold and sort laundry; load, transfer and unload a washer; bed-making with bimanual sheet handling; and bin change and bag tie. A laundry cycle is described as spanning a hamper, a hallway, a machine and a folding surface, so a spec can cover the whole arc or one stage of it.

These are captured in home settings: living space, bedroom, bathroom, utility room, and stairs and hallway. The site does not list other garments, towels or other soft items as tasks, and this page does not add them. If your task is not on the list, treat it as a skill-spec question to settle in a Spec Pilot rather than an assumption.

Skill spec

How does a skill spec define a deformable task?

You describe the task your pipeline needs covered and that becomes a written skill spec. For a deformable task it names the task and its sub-steps, their order, the setting, and the items involved. It also defines where an attempt starts and ends and what counts as a completed attempt, such as a finished fold or a made bed.

That definition lives in the spec and in the episode boundaries. It is not a separate cloth-state or garment-pose label, because none is listed among the delivered fields. The spec also sets the capture tier, annotation depth and the accept criteria, and states how much failure and recovery coverage to include alongside clean completions.

It is quoted for reach, timeline and price before any capture begins, and the accept criteria are signed into it, so acceptance is measured against what was agreed rather than judged afterwards. The skill spec guide linked below walks through how to write one.

Capture

How is the data captured?

Paid, consented contributors perform the real task against the spec while wearing the capture rig. The instrumented tier is a head-mounted stereo rig: first-person RGB, with a metric depth stream recovered from the calibrated stereo rig rather than from a standalone depth sensor, and 6-DoF IMU data at 200 Hz from head- and wrist-mounted sensors.

Every stream is hardware-triggered onto one PTP clock domain, with int64 nanosecond timestamps per stream, so depth, motion and hand pose are aligned to the same video frame rather than approximated afterwards. The rig is calibrated before capture and again after the session ends. Force and tactile readings are not among the streams listed here.

Collection is on demand: you do not need a standing program, and a focused brief is a normal starting point.

Labels

Which labels and fields ship with each episode?

Each attempt is one episode. Inside it, action segments divide the task into start- and end-timestamped spans, one per sub-step, each carrying start_ns, end_ns, verb and noun. The other fields are the standard episode schema: hand_joints and hand_visible for 3D hand pose with a per-joint visibility flag, contact_events for the moment the hand meets the item, objects, and instance_masks.

For deformable items the instance masks matter most. The site states they are shipped per frame rather than propagated, and that instance masks are stored at the depth resolution, 848×480, so they line up with the synchronized depth stream. None of these are extra fields specific to deformable capture; the table below maps each label to its delivery field.

Variation

How do slips, re-grasps and retries appear in a deformable task?

Soft items slip, bunch and need a second attempt, and a policy trained only on clean runs has no model of what to do next. Failure and recovery cases are part of the same labeled structure as a clean attempt, and a written spec can require them in the batch. Our failure and recovery page covers this in more depth.

QA

How is the data QA’d before delivery?

Acceptance is measured against signed accept criteria written into the spec before capture begins. Each batch goes through per-batch QA, and a reject log ships with every batch. An episode is accepted only if RMS reprojection stays under 0.28 px and the drift is within tolerance; otherwise it goes to the reject log.

Only footage that clears the criteria is billed as a validated hour, and rejected items are recaptured at our cost. Many teams start with a Spec Pilot: a small, fast first batch that proves the spec and the accept criteria before you scale volume.

Licence and delivery

What do you receive, and under what licence?

The buyer owns it. Every custom collection is delivered under a perpetual, non-exclusive commercial license by default, with exclusivity available, so the dataset can be trained on and productized without a research-only or unstated arrangement. Every episode is linked to a signed contributor release under a documented consent chain, and faces and screens in frame are detected and irreversibly blurred at ingest, with a reviewer confirming the result before anything ships. Clips that cannot be de-identified are discarded rather than delivered.

Delivery is in the format your stack already reads: RLDS, LeRobot, WebDataset, HDF5, zarr or Rerun .rrd, or raw streams with metadata. Readable converter source ships alongside the data so the schema can be retargeted to your own loader.

Speed

How fast can deformable-object data be delivered?

From signed spec to first validated batch, the timeline is a median of 48 hours where coverage is deep and three to four weeks where it is thin and contributors need to be recruited first. After the first batch, on-demand top-ups run against the same accept criteria, so you can add more attempts or more variation without rewriting the spec.

Getting started

How do you request it?

Describe the deformable task, its sub-steps and their order, the setting, and the failure or variation cases your pipeline is missing. That becomes a written skill spec, quoted for reach, timeline and price before capture begins, and most programs run a Spec Pilot first.

At a glance

What you get.

Starting point
Written skill spec naming the deformable task, its sub-steps and its start and end
Unit of delivery
One episode per full attempt, with ordered action segments
Capture
Head-mounted stereo rig, depth from the calibrated stereo rig, IMU
Labels
3D hand pose · per-joint visibility · contact events · action segments · instance masks
QA
Per-batch QA; accepted only under the 0.28 px RMS reprojection gate
Privacy
Faces and screens blurred at ingest; undeidentifiable clips discarded
License
Perpetual, non-exclusive, buyer-owned by default
Formats
RLDS, LeRobot, WebDataset, HDF5/zarr, Rerun RRD

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.

Stated tasks

Stated deformable task × skill-spec elements × labels delivered

Only the deformable tasks this site already lists. Labels are the standard episode fields; no task-specific cloth-state label exists.
Stated deformable taskSkill-spec elementsLabels delivered
Fold and sort laundrySub-steps, order, start and end of a completed fold, setting, itemsAction segments, 3D hand pose with visibility flags, contact events, per-frame instance masks
Load, transfer, and unload a washerStages of the laundry cycle, setting, items involvedAction segments, hand pose, contact events, objects
Bed-making, bimanual sheet handlingBoth-hand sub-steps, order, what counts as a made bedAction segments, hand pose for both hands, contact events, per-frame instance masks
Bin change and bag tieSub-steps, setting, what counts as a completed tieAction segments, hand pose, contact events, per-frame instance masks
Failure and recovery casesWhich slips and retries the batch must includeRecovery labeled inside the same episode structure

Fields

Firsthand label × what it records × delivery field

Each label and the field it is delivered in, as listed on the episode schema and delivery format pages.
LabelWhat it recordsDelivery field
EpisodeOne full attempt at the task, start to finishmeta.json: episode_id, skill_id, duration_ns
Action segmentsStart- and end-timestamped spans, one per sub-stepannotations/action_segments (start_ns, end_ns, verb, noun)
3D hand pose21 joints per hand, with a per-joint visibility flag for occluded fingersannotations/hand_joints, hand_visible
Contact eventsThe moment the hand meets the itemannotations/contact_events
Instance masksPer-frame masks of the item, stored at the depth resolutionannotations/instance_masks (848×480)
ObjectsItems named in the skill specannotations/objects
Depth and IMUDepth from the calibrated stereo rig; IMU from head and wrist sensorsstreams/depth_mm, imu_head, imu_wrist_l/r
Calibration and acceptanceAccepted only under the 0.28 px RMS gatecalibration/rms_reproj_px; calib_drift_mm; meta.json reject_flags

Which page

This page vs. neighboring pages on this site

How this deformable-object page differs from related pages. Each links to its own detail.
PageMain focusWhat you get from it
Egocentric deformable object manipulation data (this page)Buying custom first-person demonstrations of the deformable tasks the site listsA specced collection of episodes with action segments, hand pose and instance masks
Dexterous manipulation dataFine hand manipulation in generalHand-centric capture across dexterous skills
Household robot pretraining dataPretraining-scale capture across homes, rooms, objects and peopleBreadth across households rather than one deformable task
Household chores datasetThe existing catalog dataset of home choresA dataset to review, rather than a custom collection
Action-labeled egocentric videoAction labels on first-person videoLabeled segments across any task
Long-horizon egocentric task dataLong, multi-step end-to-end tasksEpisodes with ordered action segments

FAQ

Egocentric deformable object manipulation data, answered.

What is egocentric deformable object manipulation data?
First-person video and synchronized sensor data of a person handling soft, shape-changing items such as laundry, bedding and bags, delivered as episodes divided into timestamped action segments, with 3D hand pose and contact events.
Which deformable tasks does Firsthand capture?
The tasks this site lists: fold and sort laundry, load, transfer and unload a washer, bed-making with bimanual sheet handling, and bin change and bag tie. A task outside that list is settled in the skill spec and a Spec Pilot.
How is this different from household pretraining data?
Household pretraining is broad capture across many homes, objects and people. This page is about buying a custom collection focused on the deformable task itself, specified and labeled to your skill spec.
Are there cloth-state or garment-pose labels?
No. The delivered fields are the standard episode schema: action segments, 3D hand pose with visibility flags, contact events, objects and per-frame instance masks. Completion of a fold or a made bed is defined in the skill spec and the episode boundaries.
Do you capture force, tactile, robot or teleoperation data?
No. Firsthand captures first-person human demonstrations. Using them for a specific robot means bridging the embodiment gap, for example by retargeting or pairing with robot data.
How are slips and retries handled?
They are part of the same labeled structure as a clean attempt. A written spec can require failure and recovery cases in a batch.
How fast can a first batch arrive, and who owns the data?
A median of a median of 48 hours from signed spec to first validated batch where coverage is deep, and three to four weeks where it is thin. The buyer owns the delivered data under a perpetual, non-exclusive commercial license by default, with exclusivity available.
Which formats does it ship in?
RLDS, LeRobot, WebDataset, HDF5, zarr and Rerun .rrd, or raw streams with metadata, with readable converter source included so the schema can be retargeted to your own loader.

Need custom deformable-object data?

Tell us the task, its sub-steps and their order, and the slips and retries your pipeline needs covered. We will turn it into a written skill spec and run a Spec Pilot before scaling to a full collection.