Skip to main content

Dexset

dexset
Menu
Request a Demo

Category: Data Economics & Pricing

5 Hidden Costs in Robot Training Data Budgets (and How to Solve Each One)

Posted on by Sainath Gupta

Two teams we worked alongside last year signed for near-identical manipulation datasets at headline rates within a few dollars of each other. One closed its program roughly on budget. The other overran by nearly half and cut a planned training run to pay for it. The difference was never the rate. It was five quieter line items that neither quote itemized, and only one team went looking for them before signing.

I review DexSet’s QA ledgers, so I watch this pattern from the inside, and it supports one claim, which is the thesis of this post: data budgets die in the gap between quoted raw hours and delivered usable hours, and the five costs below are that gap, itemized. Teams negotiate hard on the dollars-per-hour figure, sign, and then watch these quieter items add 30 to 80 percent to the program. By the time the overrun is visible, the training run is scheduled and there is no negotiating position left.

These five costs stay hidden for a structural reason: they live in the gaps between quote and delivery. A quote prices raw hours; delivery is measured in usable, annotated, retrievable hours. Everything between those two definitions is where money leaks, and vendors have little incentive to itemize a gap that flatters their pricing.

This post names the five, puts our real numbers on each, and gives you the fix. All figures come from DexSet’s own pipeline benchmarks and program ledgers; where public hardware anchors exist, like the roughly $20k ALOHA rig, they are cited.

Read it before you sign anything. Then take the checklist at the bottom into your next vendor call.

Key Takeaways

  • QA rejection (10 to 30% in our pipelines) is the largest hidden cost: a $40 quote at 25% rejection is really $53.33 per usable hour.
  • Annotation scope creep adds $8 to $25 per hour per pass; label only selected data, not the whole corpus.
  • Rig downtime and recalibration silently cut utilization; every idle shift raises amortization per hour.
  • Storage, egress, and versioning run 3 to 6% of capture spend and spike at training time.
  • Operator turnover resets a 30 to 50% throughput learning curve; retention is a data-cost lever.

1. QA Rejection: The Gap Between Raw Hours and Usable Hours

QA rejection cost is the money spent capturing episodes that never enter your training set, and it is invisible in any quote expressed per raw hour. In our pipelines, 10 to 30 percent of raw episodes fail review: dropped frames, desynchronized views, occluded end-effectors, failed task completions.

The math bites harder than teams expect:

Quoted rate Rejection rate Real cost per usable hour Hidden premium
$30 10% $33.33 +11%
$40 25% $53.33 +33%
$50 30% $71.43 +43%

The fix. Three contract clauses. One: the vendor reports a measured rejection rate from a comparable program, not an aspiration. Two: recollection of rejected episodes is priced in writing, ideally on the vendor’s account above an agreed threshold. Three: you run a 100-to-200-hour paid pilot scored against your acceptance spec before any volume commitment. On our programs, a versioned task spec alone typically pulls rejection from the high 20s to under 15 percent within a few weeks.

2. Annotation Scope Creep: Paying for Labels You Never Train On

Annotation scope creep is the gradual expansion of labeling passes across an entire corpus when only a subset of the data needs them. Each pass costs real money: $8 to $12 per data hour for language instructions, $10 to $16 for subtask segmentation, $18 to $25 for dense masks and contact labels, per our benchmarks.

The failure mode is ordering “full annotation” on day one, before anyone knows which slices the model will actually consume. A 10,000-hour corpus with three blanket passes at a mid-range $38 per hour combined is $380,000 of labels, and in our experience a meaningful fraction of densely labeled episodes never influence a training run.

The fix. Stage it. Label language instructions broadly if your VLA needs them, then gate expensive passes behind data selection: annotate the episodes your curriculum actually samples. Run labeling in tranches with a two-week lag behind training experiments, so label spend follows demonstrated need. Teams that stage annotation typically spend 40 to 60 percent less on labels for the same eval performance.

3. Rig Downtime and Recalibration: Utilization Is the Denominator

Downtime cost is the amortization you pay while a rig is not collecting: maintenance, recalibration, resets, and idle shifts all raise the hardware cost of every hour that does get captured. A roughly $20k ALOHA-class cell (https://arxiv.org/abs/2304.13705), or a $32k Mobile ALOHA (https://arxiv.org/abs/2401.02117), is cheap only when it runs.

The numbers move fast. At two-shift utilization over 18 months, amortization is $4 to $9 per hour. Single shift with 50 percent idle time, and the same rig charges you $15 or more per hour before anyone touches a leader arm. Multi-camera exocentric arrays are worse offenders: calibration after every scene change eats 5 to 15 percent of scheduled collection time if it is not engineered out.

The fix. Treat utilization as a weekly KPI. Schedule calibration and scene resets into shift handovers, keep spare grippers and cameras on the shelf (a $600 spare beats a lost shift), and pre-stage scenes so operators walk into ready cells. If you are buying rather than building, ask the vendor how many shifts their rigs run; their utilization sets the amortization share baked into your rate.

4. Storage, Egress, and Versioning: The Bill That Arrives at Training Time

Data infrastructure cost is the spend on storing, versioning, and moving your dataset, and it stays invisible until the first big training run pulls the whole corpus out of cloud storage. Multi-view stereo capture generates terabytes per week; a 10,000-hour multi-camera program can produce several hundred terabytes before compression decisions are made.

Our planning figure is 3 to 6 percent of capture spend for storage, format conversion, and dataset versioning, with egress as the spike risk: pulling a few hundred terabytes across clouds at list egress prices can add tens of thousands of dollars per full-corpus read.

The fix. Decide storage format and residency before collection starts, not after. Co-locate data with training compute to kill egress. Standardize on a training-ready format on delivery (for example, LeRobot-compatible datasets, https://github.com/huggingface/lerobot, rather than raw ROS bags), so you pay conversion once. Version at the episode level so experiments pull slices, not the whole corpus.

5. Operator Turnover: The Learning Curve You Pay For Twice

Operator turnover cost is the throughput and quality you lose when a trained teleoperator leaves and a new one restarts the learning curve. In our programs, operators improve 30 to 50 percent in episodes-per-shift over their first 200 hours, and their rejection rates fall in parallel. Every departure resets both curves.

This cost hides inside blended rates. A vendor churning operators quietly delivers you a workforce that is permanently early-curve: slower, more rejected episodes, same invoice. You will never see a line item for it.

The fix. Ask vendors for operator tenure and how many hours their median operator has logged. In-house, pay experienced operators above generic labor rates; the throughput math justifies it easily. And instrument per-operator metrics, episodes per shift and rejection rate, so coaching happens before quality drifts.

The Pre-Signature Checklist

A pre-signature checklist converts these five hidden costs into questions a vendor must answer in writing before you commit volume:

  • ☐ Measured QA rejection rate on a comparable program, and who pays for recollection
  • ☐ Itemized rate card: capture, QA, each annotation pass ($8 to $25/hr range), infrastructure
  • ☐ Rig utilization (shifts per day) behind the amortization in the rate
  • ☐ Delivery format, storage residency, and who pays egress
  • ☐ Median operator tenure and hours logged
  • ☐ 100-to-200-hour paid pilot scored against your acceptance spec

If a vendor stalls on more than one of these, the hidden costs are not hidden from them. They are hidden from you. The full rate benchmarks behind every number in this post are published in our robot training data costs and pricing guide.

Audit Your Next Quote Against These Five

Ready to scope your data program? Talk to our team.

Request a Quote

Frequently Asked Questions

What is the single biggest hidden cost in robot training data?

QA rejection. At the 10 to 30 percent rejection rates we measure, a quoted raw-hour rate understates the true cost per usable hour by 11 to 43 percent. It is the first number to demand from any vendor.

$8 to $25 per data hour per pass in our benchmarks: language instructions at the low end, dense masks and contact labels at the top. Staging annotation behind data selection typically cuts label spend 40 to 60 percent.

Plan 3 to 6 percent of capture spend, and engineer egress out by co-locating data with training compute. Multi-view stereo programs can reach hundreds of terabytes, so format and residency decisions belong before collection starts.

Throughput improves 30 to 50 percent over an operator’s first 200 hours and rejection falls in parallel. High-churn workforces deliver permanently early-curve performance at the same hourly rate.

Use the six-question checklist above: measured rejection rate, itemized rates, rig utilization, delivery format and egress liability, operator tenure, and a paid pilot against your spec.

Case Study: Scaling a VLA Training Data Program from 500 to 12,000 Usable Hours Without Doubling the Budget

Posted on by Enoch Pakanati

Cell F14 of the spreadsheet a VLA startup sent us in January read cost_per_usable_hr = $71. Two rows down sat the scaling plan: 12,000 usable hours by July, up from the 500 they had collected on an internal ALOHA-class cell before their policy plateaued. At $71 per usable hour, the plan cost $852,000. The approved budget in the adjacent column was $560,000. The engagement began, literally, as a request to make F14 say something else.

The gap behind that cell was not caused by anything exotic. Their single rig sat idle 60 percent of the day. Their rejection rate was 31 percent because task specs lived in a Slack thread. And every hour they collected was premium bimanual teleop, even the hours that existed only to teach the visual encoder what countertops look like.

This is the most common shape of scaling problem we see, and it carries the thesis this case study argues: data budgets are rescued by operational variables, rejection rate, modality mix, and rig utilization, not by rate negotiation. Names and identifying details are removed at the client’s request; every number is from the actual program ledger.

What follows: the starting cost baseline, the three changes that moved it, the month-by-month rejection curve, and the final economics. If you are scaling any demonstration data program past a few thousand hours, at least one of these three changes applies to you.

Key Takeaways

  • Starting point: $71 per usable hour, 31% QA rejection, one under-utilized rig. Ending point: $46 per usable hour, 11% rejection, 12,100 usable hours delivered.
  • Fix 1: a written, versioned task spec cut rejection from 31% to 14% in five weeks. Cost: about a week of engineering time.
  • Fix 2: a 65/35 modality split (egocentric pretraining at $22/hr blended, teleop post-training at $44/hr blended) cut the blended rate by 29%.
  • Fix 3: two-shift rig utilization dropped amortization per hour from $11 to $5.
  • Total spend: $557,000 against a $560,000 budget. The policy’s task success rate improved 19 points on their internal eval.

The Baseline: Why $71 per Usable Hour Happens

A cost baseline is the fully loaded spend per QA-passed hour at the start of an engagement, and it is almost always worse than the team believes because rejection losses hide inside it. The startup quoted their internal cost as “about $49 an hour.” That was spend divided by raw hours. Divided by usable hours, it was $71.

Their baseline decomposed like this:

Line item Their baseline Notes
Rig amortization $11/raw hr One ~$26k cell, single shift, idle 60% of the day
Operator labor $29/raw hr Two part-time operators, still early on the learning curve
QA review $9/raw hr Manual review, no automated pre-checks
Raw total $49/raw hr The number they quoted internally
Rejection rate 31% Ambiguous specs, no calibration checklist
Usable total $71/usable hr $49 / (1 - 0.31)

Nothing in that table is negligence. It is what a research-grade pipeline looks like when a training run suddenly demands production volume. The ALOHA hardware itself was fine; a roughly $20k bimanual rig is a proven design (https://arxiv.org/abs/2304.13705). The economics around the hardware were the problem.

Fix 1: A Versioned Task Spec Cut Rejection by More Than Half

A task specification is a written, versioned document defining episode start states, success criteria, camera framing requirements, and reset procedures, and it is the highest-ROI artifact in any capture program. Theirs was a Slack thread and tribal memory. Operators guessed, and QA rejected the guesses.

We replaced it with a two-page spec per task family: exact object sets, start-state photos, an explicit success predicate, and a pre-episode calibration checklist. Rejections got tagged with a reason code so the spec could be patched weekly.

The rejection curve over the program:

Month Rejection rate Main rejection driver
Jan (baseline) 31% Ambiguous success criteria
Feb 22% Camera framing drift
Mar 14% Occluded end-effector
Apr 12% Long-horizon task failures
May to Jul 11% Steady state

Total cost of the fix: roughly one engineer-week plus 30 minutes of weekly maintenance. Effect: every subsequent dollar bought 29 percent more usable data. No other intervention in this program came close on ROI.

Fix 2: Stop Buying Premium Hours for Non-Premium Jobs

Modality staging is the practice of assigning cheap capture modalities to pretraining objectives and reserving teleoperation for action-supervised post-training. The startup was training their visual encoder on $49-per-hour bimanual teleop footage. The encoder did not care that the footage had action labels; it needed diverse pixels of hands, objects, and scenes.

We restructured the volume: 65 percent egocentric human video for representation pretraining, collected across 40+ real kitchens and workspaces at a blended $22 per hour, and 35 percent bimanual teleop for post-training at a blended $44 per hour. This mirrors what the public record already suggested: cross-source mixtures train stronger generalists, which is the entire premise of Open X-Embodiment’s 1M+ trajectories across 22 embodiments (https://arxiv.org/abs/2310.08864) and DROID’s 76k episodes across 52 buildings (https://arxiv.org/abs/2403.12945).

Blended raw rate after the split: $29.70 per hour, a 29 percent reduction against their all-teleop plan. Their ML lead’s initial worry, that ego data would not move policy metrics, resolved in evaluation: the encoder pretrained on the ego corpus reached the same downstream success with 22 percent fewer teleop post-training hours. The cheap data made the expensive data go further.

Fix 3: Utilization Is a Pricing Decision

Rig utilization is the fraction of available hours a capture station spends collecting, and it directly divides your amortization cost per hour. One cell on one shift with 60 percent idle time was charging them $11 per hour just for hardware.

Changes: we added a second shift on their existing cell, stood up two DexSet production cells in parallel, and scheduled resets and calibration into shift handovers instead of collection time. Amortization dropped to $5 per hour. Operator throughput also compounded, as it always does; our operators improve 30 to 50 percent over their first 200 hours, and by April the program’s episodes-per-shift was up 41 percent against baseline.

The Final Ledger

Program economics are only credible as a closed ledger, so here is the whole thing:

Item Plan (their original) Actual (restructured)
Usable hours target 12,000 12,100 delivered
Blended raw rate $49/hr (all teleop) $29.70/hr (65/35 mix)
Rejection rate 31% 11% steady state
Cost per usable hour $71 $46
Language annotation not budgeted $10/usable hr on teleop subset ($42,400)
Total spend $852,000 projected $557,000 actual

Against their internal eval suite, task success improved 19 points over the plateaued January checkpoint. We do not claim the data mix deserves all of that credit; their team shipped model improvements in the same window. We do claim the counterfactual: at $71 per usable hour, the volume that enabled those experiments would not have fit the budget.

Every formula behind this ledger, including the cost-per-usable-hour tables and the rig amortization model, is published in our robot training data costs and pricing guide.

What Transfers to Your Program

A transferable lesson is one that holds regardless of embodiment or task list, and this program had three. Write the task spec before you scale, because rejection rate is the multiplier on everything. Split modalities by training objective, because encoders do not need action labels. And treat utilization as pricing, because an idle rig is a fee you pay for nothing. None of these require our involvement to implement. They do require someone to own cost per usable hour as a weekly metric.

Apply This Playbook to Your Program

Ready to scope your data program? Talk to our team.

Request a Quote

Frequently Asked Questions

How many usable hours does a VLA program actually need?

It varies by task breadth and model scale, but the programs we run for post-training typically land between 5,000 and 30,000 usable teleop hours, on top of larger and cheaper pretraining corpora. Budget from your eval targets backward, not from a round number.

With a versioned task spec and calibration checklists, 10 to 15 percent is a realistic steady state in our pipelines. Above 25 percent, fix your spec before you buy another hour.

In this program, encoder pretraining on egocentric video reached equal downstream success with 22 percent fewer teleop post-training hours. Results vary with task overlap, but the direction is consistent across our engagements.

$46, down from a $71 baseline: a 35 percent reduction from spec discipline, modality staging, and rig utilization combined, with no reduction in QA standards.

The task spec and utilization fixes, yes, immediately. The modality split needs access to egocentric collection at scale, which is harder to stand up internally; that is typically where teams engage a provider.

The Robot Training Data Costs and Pricing Guide contains every benchmark and formula used in this program. Or book a scoping call and we will baseline your current cost per usable hour in one session.

Teleop, Egocentric, Exocentric, or Handheld: Comparing Robot Training Data Approaches by Cost

Posted on by Sainath Gupta

In February, we priced the same 5,000-hour manipulation corpus three different ways for one buyer: all bimanual teleoperation at a blended $44 per hour, a 65/35 egocentric-to-teleop mix at just under $30, and a handheld-gripper-heavy plan in between. Same task list, same acceptance spec. The spread between the first two plans came to roughly $70,000.

I build teleop cells for a living, so this is not an argument against teleoperation. It is the thesis that quoting exercise made unavoidable: modality selection is a budgeting decision, and the right modality for each training objective is the cheapest one that actually satisfies it. For plenty of what your model needs to learn, the premium teleop hour is simply the wrong purchase.

Teams get this wrong in both directions. Some buy 20,000 hours of premium teleop and burn budget teaching their encoder what a kitchen looks like, a job $18-per-hour egocentric video does fine. Others go all-in on cheap human video and then discover their policy has beautiful representations and no idea how to move an actual gripper.

The reason the mistake is so common is that modality costs and modality capabilities are usually discussed separately. Cost tables live in procurement decks; capability arguments live in arXiv papers. This post puts them in one place, with DexSet’s operating benchmarks attached, so you can match each dollar to the learning objective it actually serves.

By the end you will have per-hour costs for four collection approaches, an honest pros-and-cons list for each, and a decision matrix that maps training objectives to the cheapest modality that satisfies them.

Key Takeaways

  • Teleoperation ($28 to $60/hr) is the only approach that outputs executable robot actions natively. Pay for it where action supervision matters.
  • Egocentric human video ($15 to $40/hr) is the cheapest volume play, best for representation pretraining, worst for the embodiment gap.
  • Multi-view exocentric capture ($20 to $50/hr) buys scene context and cross-view consistency; calibration labor is its hidden cost.
  • UMI-style handheld grippers (under $1k per device by our estimates) collect gripper-centric data at near-egocentric labor cost, with heavier post-processing.
  • QA rejection (10 to 30 percent in our pipelines) and annotation ($8 to $25/hr per pass) apply to all four. Compare on cost per usable hour.

The Four Approaches, Defined

A data collection approach is the pairing of a capture device with a control source: robot teleoperation, head-mounted egocentric capture, calibrated exocentric camera arrays, or handheld instrumented grippers. Everything else, mono versus stereo, camera count, annotation depth, is a variation within these four.

Teleoperation: $28 to $60 per Hour

Teleoperation data is produced by a human driving a real robot through leader-follower arms or a VR interface, so every recorded frame pairs observations with executable actions in the robot’s own action space. The ALOHA project showed this could be done on a roughly $20k bimanual rig (https://arxiv.org/abs/2304.13705), and Mobile ALOHA extended it to whole-body mobile tasks on roughly $32k of hardware (https://arxiv.org/abs/2401.02117).

Pros

  • Native action labels; feeds imitation learning and VLA post-training directly
  • Matches your exact embodiment, gripper, and camera placement
  • Long-horizon, contact-rich tasks are demonstrable at production quality

Cons

  • Highest labor cost: trained operators at $18 to $38 per hour, plus rig amortization and QA
  • Throughput capped by operator skill and episode reset time
  • Data is embodiment-specific; switching robots strands some of its value

Egocentric Human Video: $15 to $40 per Hour

Egocentric data is first-person video from a head-mounted camera while a human performs tasks with their own hands, capturing human-level dexterity with no robot in the loop. Ego4D and EgoExo4D (https://arxiv.org/abs/2311.18259) made the research case; the commercial case is pure economics, since the collector works at natural speed on tasks they already know.

Pros

  • Cheapest per hour; scales to thousands of hours quickly
  • Enormous task and scene diversity, including real homes
  • Strong pretraining signal for visual encoders and hand-object interaction priors

Cons

  • No robot actions; the embodiment gap means it rarely supervises control directly
  • QA rejection skews high (motion blur, gaze drift, occlusion), 15 to 30 percent in our pipelines
  • Needs retargeting or paired data to transfer to a gripper

Multi-View Exocentric Capture: $20 to $50 per Hour

Exocentric data is third-person video from multiple calibrated, synchronized cameras observing the same task, giving models scene-level context and cross-view consistency that neither ego nor teleop streams provide alone. Stereo pairs add 15 to 25 percent over mono at the same view count and buy metric depth in return.

Pros

  • Full-scene coverage; occlusions in one view are recovered in another
  • Calibrated multi-view supports 3D reconstruction and world-model training
  • Pairs well with egocentric streams (the EgoExo4D recipe)

Cons

  • Calibration and synchronization labor at every scene change is the silent budget eater
  • Fixed arrays limit scene diversity; mobile arrays raise cost
  • Still no action labels without a paired control source

Handheld Instrumented Grippers (UMI-style): Near-Egocentric Cost, Gripper-Centric Output

Handheld gripper capture uses a portable, wrist-camera-equipped gripper operated by a human, producing gripper-centric trajectories without any robot present at collection time. The UMI paper (https://arxiv.org/abs/2402.10329) defined the category; our build estimate is under $1,000 per device including the camera.

Pros

  • Capex is trivial next to a $20k to $32k teleop cell
  • Collection happens anywhere a person can walk, at near-egocentric labor rates
  • Output is closer to robot action space than raw human video

Cons

  • Heavier post-processing to recover clean actions (SLAM drift, kinematic mismatch)
  • Gripper form factor constrains which tasks are demonstrable
  • QA tooling for this modality is younger; expect iteration

Master Comparison Table

Approach DexSet cost/raw hr Capex per station Action labels QA rejection Best use
Teleoperation $28 to $60 $20k to $32k Native 10 to 25% VLA post-training, imitation learning
Egocentric video $15 to $40 $300 to $3.5k None 15 to 30% Encoder pretraining, dexterity priors
Exocentric multi-view $20 to $50 $5k to $15k (3 to 8 cams) None 10 to 20% Scene context, world models, 3D
Handheld gripper (UMI-style) $18 to $42 (our estimate) Under $1k/device Recoverable 15 to 25% Diverse-scene manipulation at low capex

Annotation is additive to every row: $8 to $12 per hour for language instructions, up to $18 to $25 for dense masks and contact labels. And every row’s real price is its cost per usable hour: divide by (1 minus rejection rate). The full math, with a budget spreadsheet, lives in our robot training data costs and pricing guide.

Decision Matrix: Match the Dollar to the Objective

A modality decision matrix assigns each training objective the cheapest approach that actually satisfies it, instead of defaulting everything to the premium modality. Here is the one we use in scoping calls:

Your objective Buy this Not this Why
Post-train a VLA on your robot Teleoperation Egocentric You need native actions on your embodiment
Pretrain visual encoders at volume Egocentric Teleoperation Paying $42/hr for pixels is waste
Scene diversity across 100+ homes Handheld gripper or egocentric Fixed exo array Portability beats calibration
Depth-dependent manipulation Stereo exo + teleop Mono anything Metric depth earns its 15 to 25% premium
World-model or video-prediction training Exo multi-view + ego pairs Teleop only Cross-view consistency is the signal
Bimanual, contact-rich skills Teleoperation (ALOHA-class) Handheld gripper Two grippers, force-aware demos

The pattern behind the matrix: mix modalities and stage them. Open X-Embodiment’s 1M+ trajectories across 22 embodiments (https://arxiv.org/abs/2310.08864) and DROID’s 76k episodes (https://arxiv.org/abs/2403.12945) already prove cross-source data mixes train better generalists. Your budget should look like a portfolio, not a single line item. A 70/30 split of cheap pretraining hours to teleop post-training hours routinely cuts blended cost by a third in programs we run, with no loss on the action-supervised objectives.

Match the Modality to the Objective

Ready to scope your data program? Talk to our team.

Request a Quote

Frequently Asked Questions

What is the cheapest way to collect robot training data?

Egocentric human video, at $15 to $40 per hour in our benchmarks, since hardware is a wearable camera and collectors work at natural speed. It is cheapest per hour but supplies no robot actions, so it cannot carry a program alone.

When you need executable actions on your specific embodiment: VLA post-training, imitation learning for contact-rich or bimanual skills. For those objectives nothing cheaper substitutes, which is exactly why you should not spend teleop dollars on anything else.

They are production-useful with caveats. Capex is under $1,000 per device by our estimates and scene diversity is the widest of the four approaches, but plan for heavier post-processing and a 15 to 25 percent rejection rate while the QA tooling matures.

Stereo adds 15 to 25 percent to exocentric capture cost and pays for itself on depth-dependent manipulation tasks. For pure representation pretraining, mono volume usually beats stereo precision per dollar.

Convert everything to cost per usable hour: quoted rate divided by (1 minus the measured QA rejection rate), plus annotation per pass. Our pricing guide includes the worked tables.

Start with the Robot Training Data Costs and Pricing Guide for the full benchmark tables, then book a scoping call and we will run your task list through the decision matrix above.

Why Training Data Costs Are the Biggest Bottleneck in Physical AI

Posted on by Enoch Pakanati

“Training data” is usually defined as something you gather. That definition hides the economic fact that decides robotics budgets: robot demonstration data cannot be gathered at all. Language models scraped trillions of tokens the internet had already produced for free. A robot demonstration has to be manufactured, one episode at a time, by a person and a machine in a room, and manufactured goods have unit costs that scraping never did.

That manufacturing has a price, and the price is the thesis of this post: the binding constraint on physical AI progress is the unit economics of demonstration data, not model architecture. Our benchmarks put teleoperation at $28 to $60 per hour, egocentric human video at $15 to $40, and multi-view exocentric capture at $20 to $50, before annotation adds another $8 to $25 per pass. Multiply any of those by the hundreds of thousands of hours that scaling curves suggest, and the number stops looking like a data budget and starts looking like a Series B.

Compute costs fall on a curve you can plan around. GPU-hours get cheaper every year; teleoperator-hours do not, because they are wages plus hardware plus QA. So while everyone argues about architectures, the teams actually shipping robot foundation models are constrained by a much less glamorous question: how many usable demonstration hours can we afford this quarter?

This post breaks down why the bottleneck is economic rather than algorithmic, what the per-hour math actually looks like, and where the cost curve is bending. It draws on DexSet’s own capture operations, so the numbers are operating benchmarks, not estimates.

Key Takeaways

  • Robot data is manufactured, not scraped. Teleop costs $28 to $60 per hour; egocentric video $15 to $40; multi-view exo $20 to $50 (DexSet benchmarks).
  • QA rejection of 10 to 30 percent inflates every quoted rate. Budget on cost per usable hour.
  • Open X-Embodiment needed 21 institutions to pool 1M+ trajectories across 22 embodiments; no single lab could afford that collection alone.
  • Rig capex is the small part: an ALOHA-class station is roughly $20k and amortizes fast. Labor and QA dominate.
  • The cost curve bends through cheaper capture devices (UMI-style grippers), human video pretraining, and better data selection, not through cheaper wages.

The Bottleneck Is Economic, Not Algorithmic

The physical AI bottleneck is the gap between the demonstration volume that current methods need and the demonstration volume that current budgets can buy. Imitation learning works. ACT on ALOHA hardware showed fine bimanual manipulation from a rig that cost roughly $20k (Zhao et al., https://arxiv.org/abs/2304.13705). VLA models generalize further as data grows. The recipe is not the mystery; funding the recipe is.

Look at what it took to build the field’s reference datasets. Open X-Embodiment pooled data from 21 institutions to reach more than 1 million trajectories across 22 robot embodiments (https://arxiv.org/abs/2310.08864). DROID took a multi-lab consortium collecting across 52 buildings for a year to produce 76,000 episodes (https://arxiv.org/abs/2403.12945). These are consortium projects because the economics forced them to be. When the leading academic labs in the world have to carpool, the per-hour cost of data is the constraint worth studying.

Contrast that with a startup’s position. A humanoid company that wants 50,000 proprietary teleop hours at a blended $42 per hour is staring at a $2.1M capture bill before annotation, before storage, and before the 10 to 30 percent QA rejection rate we measure in our own pipelines pushes the real figure higher. That is the bottleneck in one sentence: the marginal trajectory costs real money, and scaling laws demand a lot of margins.

Where the Money Actually Goes

A fully loaded data cost is the sum of hardware amortization, collection labor, QA review, annotation, and infrastructure, and its composition explains why the bottleneck resists quick fixes. Hardware is the layer everyone obsesses over and the one that matters least.

Cost layer Teleoperation Egocentric video Share of total (typical)
Hardware amortization $4 to $9/hr $1 to $4/hr 10 to 15%
Collection labor $18 to $38/hr $10 to $26/hr 55 to 65%
QA and recollection $6 to $12/hr $5 to $10/hr 20 to 30%
Total (raw hour) $28 to $60/hr $15 to $40/hr 100%

Two things jump out of that table. Labor dominates, and labor does not follow Moore’s law. A teleoperator in year three costs what a teleoperator cost in year one, adjusted upward for wages. The only labor lever is throughput: in our programs, operator productivity improves 30 to 50 percent over their first 200 hours, which is real but bounded.

The second thing: QA is a fifth to a third of the bill, and it is the layer buyers most often forget. An episode fails for dropped frames, a desynced camera, an occluded gripper, or a task that did not actually complete. At a 25 percent rejection rate, a $40 quote is really $53.33 per usable hour. We walk through that math, with tables, in our full robot training data costs and pricing guide.

Why Compute Got Cheap and Data Did Not

Compute costs fall because silicon improves and utilization tooling matures, while demonstration data costs stay flat because their main input is human time in physical space. This asymmetry is the strategic fact of the next five years of robotics.

A training run you could not afford in 2023 is routine in 2026. But the demonstration hour you collected in 2023 cost about what it costs today, and the scene setup, the resets between episodes, and the review pass all still happen at human speed. Physics does not batch. You cannot checkpoint a kitchen.

The practical consequence: data spend is becoming the durable moat while compute spend becomes a commodity line item. Teams that treat their data budget with the same rigor as their compute budget, tracking cost per usable hour, rejection rates, and hours-to-policy-improvement, compound an advantage that a bigger cluster cannot erase.

Where the Cost Curve Actually Bends

Cost-curve bending in robot data comes from cheaper capture devices, cheaper modalities for pretraining, and better data selection, not from paying people less. Three developments are doing real work right now.

  • Handheld capture devices. UMI-style grippers (Chi et al., https://arxiv.org/abs/2402.10329) put a wrist camera on a portable gripper, so collection happens in real homes without a robot present. Our build estimate is under $1,000 per unit. Labor cost drops toward egocentric rates while output stays gripper-centric.
  • Human video for pretraining. Egocentric data at $15 to $40 per hour can carry representation learning, reserving expensive teleop for post-training. A 70/30 ego-to-teleop mix can cut blended cost per hour by a third without giving up action supervision where it counts.
  • Data selection over data volume. Deduplication, difficulty-aware sampling, and rejecting low-information episodes before annotation mean you pay $8 to $25 per hour of labels only on data that earns it.

None of these eliminate the bottleneck. They move the ratio of usable hours per dollar, which is the correct objective.

What This Means for Your Budget

A defensible data plan starts from cost per usable hour and works backward to volume, rather than starting from a raw-hour quote and hoping. If you take one action from this post, make it this checklist:

  • Get every vendor quote itemized across hardware, labor, QA, annotation, and infrastructure.
  • Demand a measured QA rejection rate from a comparable program, and pilot before committing volume.
  • Split your pipeline: cheap modalities for pretraining volume, teleop for action-supervised post-training.
  • Track cost per usable hour monthly. It is your burn rate’s most honest line.

Put the Numbers to Work

Ready to scope your data program? Talk to our team.

Request a Quote

Frequently Asked Questions

Why is robot training data more expensive than language data?

Language data was scraped from the internet at near-zero marginal cost. Robot data is manufactured: a person, a rig, and a physical scene produce one episode at a time, at $15 to $60 per hour depending on modality, plus QA and annotation.

Collection labor, at 55 to 65 percent of the fully loaded hourly rate in our programs. Hardware amortization is only 10 to 15 percent, which is why cheaper rigs alone do not fix the bottleneck.

As a reference point, 50,000 teleop hours at a blended $42 per hour is $2.1M before annotation and before QA rejection losses of 10 to 30 percent. Consortium datasets like Open X-Embodiment exist precisely because no single lab wanted to carry that cost.

It reduces it for some skills, but sim-to-real transfer still needs real-world demonstrations for contact-rich manipulation, and mixed pipelines still budget significant real capture. Treat sim as a multiplier on real data, not a replacement.

Tighten task specs to cut QA rejections, mix cheaper egocentric or UMI-style capture into pretraining, annotate only selected data, and measure rejection rates continuously. The full cost model is in our pricing guide.

The Robot Training Data Costs and Pricing Guide publishes our complete per-hour benchmarks, rig capex table, and a downloadable budget spreadsheet. No sales call required to see the numbers.

Robot Training Data Costs and Pricing: The Complete 2026 Guide

Posted on by Sainath Gupta

In our first year we priced a 6,000-hour teleoperation program the way most of this market still prices: by the raw hour. We hit our quoted rate and still broke the client’s budget model, because 22 percent of captured episodes failed their acceptance spec and nobody’s plan had funded the recollection. We rebuilt our cost model around that miss, and this guide is the rebuilt model, published.

The mistake was possible because robot training data has no commodity unit yet. An “hour” of data can mean a raw teleop stream with 30 percent unusable episodes, or a QA-passed, annotated, deduplicated hour that trains a policy. Those two hours differ in cost by 2x or more, and vendors quietly quote whichever one makes their number look better.

So here is the thesis this guide argues from the first table to the last: the only honest unit for pricing robot training data is cost per usable hour, and every quote you receive should be converted into that unit before you compare anything. To make the conversion possible, you will get our first-hand cost-per-hour benchmarks for teleoperation, egocentric human video, and multi-view exocentric capture; rig capex figures anchored to public hardware like ALOHA and UMI; the QA rejection math that separates raw hours from usable hours; and a worked budget for a 10,000-hour VLA data program.

DexSet collects egocentric, exocentric, teleoperation, mono, and stereo data for physical AI teams. We run these rigs, staff these operators, and eat these QA rejections every week. Every number below is either our own operating benchmark or a cited public source.

TL;DR: Robot Training Data Costs at a Glance

  • Teleoperation data: $28 to $60 per raw hour (rig amortization + operator + QA), based on DexSet benchmarks.
  • Egocentric human video: $15 to $40 per hour, the cheapest scalable modality.
  • Multi-view exocentric capture: $20 to $50 per hour depending on camera count and calibration load.
  • Annotation passes: $8 to $25 per hour extra, on top of any capture modality.
  • Rig capex: ~$20k for an ALOHA-style bimanual station (per the ALOHA paper), ~$32k for Mobile ALOHA, under $1k per UMI-style handheld gripper by our build estimates.
  • QA rejection runs 10 to 30 percent in our pipelines, so always budget on cost per usable hour, not raw hour.
  • Public scale references: Open X-Embodiment aggregates 1M+ trajectories across 22 embodiments; DROID contains 76k episodes.

What Do Robot Training Data Costs Actually Include?

Robot training data cost is the fully loaded price of producing one hour of demonstration data that a robot learning pipeline can actually consume, covering hardware amortization, operator or collector labor, QA review, annotation, and delivery infrastructure. Most published debates skip half of these line items, which is why budgets built from a single “per hour” quote fall apart in month two.

A defensible cost model has five layers:

  • Capture hardware (capex). Teleop stations, headsets, camera arrays, grippers. Amortized over 12 to 24 months of use.
  • Collection labor (opex). Teleoperators, camera-wearing collectors, scene setup staff. Usually the largest single line.
  • QA and curation (opex). Human review, automated checks, rejection and recollection. The most commonly omitted layer.
  • Annotation (opex). Language instructions, segmentation, keyframes, success labels. Priced per pass.
  • Infrastructure (opex). Storage, upload bandwidth, format conversion, dataset versioning.

When a vendor quotes you a single number, ask which of these five layers it covers. In our experience the quoted number usually covers layers 1 and 2 and quietly excludes 3 through 5, which add 30 to 80 percent on top.

Core Modalities and What Each One Costs

A data modality is the combination of sensor viewpoint and control method used to produce demonstrations: teleoperation, egocentric human video, exocentric multi-view capture, and their mono or stereo variants. Each modality has a distinct cost structure because each one shifts spend between hardware, labor, and QA differently.

Teleoperation Data: $28 to $60 per Hour

Teleoperation data is demonstration data produced by a human directly controlling a robot, typically through a leader-follower arm setup or a VR interface, so the recorded actions are executable robot trajectories. It is the gold standard for imitation learning and VLA post-training because actions come out in the robot’s own action space, but it is also the most expensive modality per hour.

Our benchmarks across bimanual manipulation programs:

  • Rig amortization: $4 to $9 per hour (a $20k to $32k station amortized over 18 months of two-shift use, including maintenance and spare grippers).
  • Operator labor: $18 to $38 per hour depending on region, task dexterity, and whether the task needs trained specialists (cable routing and garment handling sit at the top of that range).
  • QA overhead: $6 to $12 per hour, covering episode review, rejection, and partial recollection.

Total: $28 to $60 per raw teleop hour. Long-horizon mobile manipulation lands at the top of the range; tabletop pick-and-place with experienced operators lands at the bottom.

The entity chain matters here: teleoperation feeds imitation learning methods like ACT, which the ALOHA project introduced, and imitation learning at scale is what current VLA models are built on. The ALOHA paper (Zhao et al., “Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware,” https://arxiv.org/abs/2304.13705) demonstrated that a roughly $20k bimanual rig could produce data good enough for fine manipulation, which reset industry assumptions about capture hardware pricing.

Egocentric Human Video: $15 to $40 per Hour

Egocentric data is first-person video captured from head-mounted or body-mounted cameras while a human performs tasks with their own hands, giving models human-level dexterity examples without any robot in the loop. It is the cheapest modality to scale because the “rig” is a wearable and the collector is doing a task they already know how to do.

Our cost structure:

  • Hardware amortization: $1 to $4 per hour. Headsets and head-mounted cameras cost $300 to $3,500 and survive thousands of capture hours.
  • Collector labor: $10 to $26 per hour.
  • QA overhead: $5 to $10 per hour. Egocentric QA is dominated by motion blur, gaze drift, and occlusion checks.

Total: $15 to $40 per hour. The catch is the embodiment gap: human hands are not robot grippers, so egocentric data usually pretrains representations rather than directly supervising actions. Datasets like Ego4D and EgoExo4D (https://arxiv.org/abs/2311.18259) established the research value of this modality; the commercial question is purely about cost-effective volume.

Multi-View Exocentric Capture: $20 to $50 per Hour

Exocentric data is third-person video captured from fixed or mobile external cameras observing a task from multiple calibrated viewpoints, which gives models scene context and cross-view consistency that a single egocentric stream cannot. Cost scales with camera count and, more painfully, with calibration and synchronization labor.

Our benchmarks: $20 to $50 per hour for 3 to 8 synchronized views, including calibration checks at every scene change. Stereo pairs add roughly 15 to 25 percent over mono at the same view count because of the extra calibration and QA burden, but they buy you metric depth, which matters for manipulation policies.

Annotation: $8 to $25 per Hour, on Top of Everything Above

Annotation cost is the incremental price of adding structured labels to captured data: language instructions, subtask segmentation, success and failure flags, object masks, or keyframe tags. It is always additive to capture cost, and it is where “cheap” datasets quietly become expensive.

Typical per-pass pricing from our pipelines:

  • Language instruction labeling: $8 to $12 per data hour
  • Subtask segmentation: $10 to $16 per data hour
  • Dense object masks or contact annotation: $18 to $25 per data hour

Comparison Table: Cost per Hour by Modality

Modality Raw cost/hour (DexSet benchmark) Hardware amortization share QA rejection rate Best suited for
Teleoperation (bimanual) $28 to $60 $4 to $9 10 to 25% VLA post-training, imitation learning
Egocentric human video $15 to $40 $1 to $4 15 to 30% Representation pretraining, hand priors
Exocentric multi-view (3 to 8 cams) $20 to $50 $3 to $7 10 to 20% Scene understanding, cross-view learning
Stereo add-on (vs mono) +15 to 25% +$1 to $2 +2 to 5 pts Depth-dependent manipulation
Annotation pass (language) +$8 to $12 n/a n/a Instruction-following VLAs
Annotation pass (dense masks) +$18 to $25 n/a n/a Grasp and contact modeling

Rig Economics: Capex Benchmarks You Can Verify

Rig capex is the upfront hardware cost of a capture station before a single hour of data exists, and it is the number that determines whether building in-house ever beats buying data. The public record here is unusually good, so you do not have to trust vendor hand-waving.

Rig Approx. capex Source Notes
ALOHA bimanual teleop station ~$20,000 ALOHA paper, https://arxiv.org/abs/2304.13705 Leader-follower arms, cameras, frame
Mobile ALOHA ~$32,000 Mobile ALOHA paper, https://arxiv.org/abs/2401.02117 Adds mobile base for whole-body tasks
DexSet production teleop cell $20,000 to $32,000 First-hand DexSet build costs ALOHA-class arms plus industrial cameras, lighting, sync hardware
UMI handheld gripper Under $1,000 per unit (our build estimate) UMI paper, https://arxiv.org/abs/2402.10329 Portable gripper with wrist camera; no robot needed at capture time
Egocentric headset kit $300 to $3,500 Consumer/enterprise hardware pricing Camera glasses to mixed-reality headsets

Two practical lessons from running these rigs:

First, capex is rarely the problem. A $26k teleop cell running two shifts amortizes to under $9 per hour within 18 months. Labor and QA dominate every mature program we run.

Second, UMI-style handheld grippers changed the low end of the market. Because the capture device is a portable gripper with a wrist camera rather than a full robot cell, collection can happen in real homes and kitchens at egocentric-like labor costs while still producing gripper-centric trajectories. The trade-off is a heavier post-processing and QA load to recover clean actions.

Cost per Usable Hour: The Number That Actually Matters

Cost per usable hour is the total program spend divided by the hours that survive quality assurance, and it is always higher than the quoted cost per raw hour. This is the single most important correction to apply to any vendor quote, including ours.

In DexSet pipelines, QA rejection runs 10 to 30 percent depending on modality and task difficulty. Episodes get rejected for dropped frames, desynchronized views, failed task completion, occluded end-effectors, or annotation mismatches. The math is unforgiving:

Usable-hour math. At $40 per raw teleop hour with a 25 percent rejection rate, your real cost is $40 / 0.75 = $53.33 per usable hour. A competitor quoting $36 per hour with an unmeasured 35 percent rejection rate is actually charging $55.38. The cheaper quote is the more expensive dataset.

Quoted raw $/hr Rejection rate True cost per usable hour
$30 10% $33.33
$30 30% $42.86
$40 15% $47.06
$40 25% $53.33
$55 10% $61.11

When you evaluate any provider, require three things in writing: the measured rejection rate on a comparable program, who pays for recollection of rejected episodes, and whether QA review labor is inside or outside the quoted rate. If a vendor cannot produce a rejection rate, they are not measuring quality.

Budgeting a Program: A Worked Example

A data budget is a forward plan that converts a target usable-hour count into total spend across capture, QA, annotation, and infrastructure. Here is a realistic model for a VLA team that needs 10,000 usable teleop hours with language annotation.

  • Target: 10,000 usable hours
  • Assumed rejection rate: 20 percent, so raw capture target = 12,500 hours
  • Blended teleop rate: $42 per raw hour = $525,000 capture
  • Language annotation at $10 per usable hour = $100,000
  • Storage, versioning, delivery at roughly 4 percent of capture = $21,000
  • Total: ~$646,000, or $64.60 per usable annotated hour

For scale context, Open X-Embodiment pooled more than 1 million trajectories across 22 robot embodiments from 21 institutions (https://arxiv.org/abs/2310.08864), and DROID contains 76,000 episodes collected across 52 buildings (https://arxiv.org/abs/2403.12945). Those datasets exist because no single lab could afford to collect that volume alone, which tells you what the market already knows: collection cost, not model architecture, is the binding constraint on physical AI progress.

Build vs Buy: When Each One Wins

The build-vs-buy decision compares the fully loaded cost of standing up your own capture operation against a vendor’s cost per usable hour at your required volume and quality bar. Neither answer is always right; the crossover depends on volume, duration, and how much operational pain you can absorb.

Build wins when you need under roughly 2,000 hours of highly proprietary, robot-specific data, you already own the robots, and engineering time is genuinely available. Buy wins when you need volume and velocity: a vendor already amortized the rigs, trained the operators past the learning curve (operator throughput improves 30 to 50 percent over their first 200 hours in our programs), and built the QA tooling you would otherwise write from scratch. Most funded teams land on a hybrid: build one internal cell for rapid task iteration, buy production volume.

Case Study Proof: A Humanoid Foundation Model Team

A humanoid foundation model team came to us with a $400k data budget, a quoted competitor rate of $35 per hour, and a plan for 11,400 hours. The quote excluded QA review and carried no measured rejection rate. On a 200-hour pilot we measured 28 percent rejection against their own spec, which repriced the competitor dataset at $48.60 per usable hour before annotation.

We restructured the program: tightened the task spec to cut ambiguity-driven rejections, moved 30 percent of volume to egocentric capture for representation pretraining, and reserved teleop for post-training data. Result: 9,800 usable hours delivered inside the original budget, with rejection stabilized at 12 percent by week six. The lesson is not that our rate was lower. It is that cost per usable hour, measured on a pilot, is the only number that predicted their final spend.

Why Most Vendors Hide Pricing, and Why We Publish It

Hidden pricing is a deliberate market structure in which vendors quote deal by deal to maximize price discrimination, and it survives because buyers lack a shared benchmark. Large annotation-era incumbents built their margins on this asymmetry, and robot data inherited the habit.

We publish our ranges because the buyers we want, Heads of Data who run pilots and measure rejection rates, are exactly the buyers opaque pricing repels. Transparent ranges cost us the occasional overpriced deal and win us every buyer who has been burned before. You should treat any vendor’s refusal to publish even a range as information about how they expect the negotiation to go.

Free Download: The Robot Data Cost Model and RFP Scorecard

We packaged the math in this guide into two working documents: a cost model spreadsheet with editable assumptions for rejection rate, shift count, and amortization period, and a 24-question RFP scorecard covering the five cost layers, QA measurement, and recollection liability. Both are free, no email gate on the scorecard.

Related Reading

Put the Numbers to Work

Ready to scope your data program? Talk to our team.

Request a Quote

Frequently Asked Questions

How much does robot training data cost per hour?

Based on DexSet’s operating benchmarks: teleoperation runs $28 to $60 per raw hour, egocentric human video $15 to $40, and multi-view exocentric capture $20 to $50. Annotation adds $8 to $25 per hour per pass. Divide any quoted rate by (1 minus the rejection rate) to get the true cost per usable hour.

The original ALOHA paper reports a bimanual rig built for roughly $20,000, and Mobile ALOHA extends it to whole-body mobile manipulation at roughly $32,000. Our production cells, with industrial cameras, lighting, and sync hardware added, land between $20,000 and $32,000.

In our pipelines, 10 to 30 percent of raw episodes fail QA, depending on modality and task complexity. Well-specified tabletop teleop can hold near 10 percent; long-horizon mobile tasks and loosely specified egocentric capture push toward 30 percent.

Building tends to win below roughly 2,000 hours of proprietary, robot-specific data when you already own robots and engineering time. Buying wins at volume because vendors have amortized rigs, trained operators, and existing QA tooling. Most teams run a hybrid.

Egocentric capture uses wearable cameras and human hands, so hardware costs hundreds to a few thousand dollars and collectors perform familiar tasks at natural speed. Teleoperation requires a $20k to $32k rig plus a trained operator, and outputs executable robot actions, which is what you pay the premium for.

Open X-Embodiment aggregates more than 1 million trajectories across 22 robot embodiments, and DROID contains 76,000 episodes. Both are useful pretraining anchors, but most teams still need proprietary data matched to their own embodiment and tasks.

Require the measured QA rejection rate on a comparable program, clarity on who pays for recollection, an itemized list of which cost layers the rate includes (hardware, labor, QA, annotation, infrastructure), and a paid pilot with your acceptance spec before any volume commitment.

Download the DexSet Robot Data Cost Model and RFP Scorecard, or book a 30-minute pricing walkthrough with our data operations team. We will run your task list through the same model we use internally and hand you the spreadsheet.