Skip to main content

Dexset

dexset
Menu
Request a Demo

Tag: QA Rejection

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.

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.