Robot inference cost per robot-hour: the 6.48 derivation

Robot policy inference costs 6.48 per robot-hour on this platform's fully shown basis: 2,160 calls per robot hour at the written-record per-call rate for the pi05 model. Every input is named and dated below. The figures circulating elsewhere, from 2 to 35 per hour, price different things: whole robots, data factories, labor parity. None derives the inference slice. This page does the arithmetic in the open, in static tables you can re-run on your own loop.

All amounts are United States dollars written as bare numerals. This page has no calculator widget. Every table is static and every input is dated, so you can check the arithmetic with a pencil.

Last verified: 2026-10-26

The answer in one line

cost per robot hour  =  C x P

C:  calls per robot hour, set by your control loop
P:  price per call, set by the rate you use

The platform's worked example runs one number through this formula. A 30 frame per second camera loop with action chunks of 50 makes C = 2,160 calls per robot hour. The written record for the pi05 model id sets P. Multiply them and the answer is 6.48 per robot hour. Two more lanes on the same basis: the small SmolVLA class lands on 2.16, and the ACT class on 2.16 as well, because their written rates sit lower in the same table.

That is the whole derivation. The rest of this page dates every input, shows what the GPU actually does for that money, and works the break-even against owning a card.

What the quoted numbers actually measure

Search for a robot's hourly cost and you meet a spread from 2 to 35 with no working shown. Each figure is real in its own frame. None of them prices inference. Here is the map, every row named and dated.

A Fortune commentary piece from October 16, 2026 put the spread plainly: whom you ask decides whether a robot costs 2, 10 to 12, or more than 35 per hour. A Figure robot review reached the same conclusion from the other side: no humanoid vendor has published a comparable unit economic, and the widely quoted figures appear in none of the primary releases.

The pattern: everyone prices the whole machine. The one line a builder can shop for, the brain, is either buried, assumed, or absent. The 5.11 build-up is the clearest case. Its four lines are hardware, maintenance, energy, and a flat 0.50 for software and cloud. That 0.50 is the only number in the table nobody can check, and it is the only one this page sets out to derive.

The call basis: from camera frames to billed calls

A robot policy does not bill per frame. It bills per call, and one call returns an action chunk: a run of joint targets computed in one pass. The arm works through the chunk while the next one computes. The count is pure arithmetic.

calls per robot hour  =  3600 x frame rate / chunk length

The first row is the SO-arm class convention this page uses throughout: a 30 frame per second camera stream and chunks of 50 actions, the shape a pi0-class policy serves. Counting camera frames instead of chunks overstates a hosted bill by exactly fifty times in that row. The camera hands you 108,000 frames an hour. The bill counts 2,160 calls.

Chunk length is set by the model's training, not by the request. A shorter chunk reacts faster and costs more per hour at any fixed per-call price. A longer chunk is smoother and cheaper. This one choice moves the bill by a factor of three or more before you touch the rate. The units themselves, per call against per robot hour, get their own treatment in the pricing units guide.

The rate side: the written record and the worked lanes

The platform's rate for its own models lives in one place, the machine table rendered from its model data. This page does not type those numbers in prose. The fence below carries the rows this page's worked example uses, verbatim values from the platform's model data as read on 2026-10-26.

The honest state, in plain words: these rows sit in the platform's model data with their rates set, and they are not on the public list as of 26 October 2026. This page quotes no live rate for them. Only listed rows render in the rendered table, and the models index is the live catalog. A written record is not a launch.

With the rate side anchored to the fence, the worked lanes at C = 2,160:

Divide any result by 2,160 and you recover the per-call rate that produced it. That is the check: the derivation inverts.

Rate levels, labeled as assumptions rather than quotes, spread the same call count across the band a buyer might meet:

Read the ladder this way: at the same loop, the rate alone spans a factor of sixty across the plausible band. Any hourly cost claim without its per-call rate and its call count is not a number. It is a mood.

The hardware basis: how much GPU a robot hour eats

What does the money buy in silicon? The reference measurement set is VLA-Perf, a February 2026 performance study from NVIDIA Research, with an open tool on the NVlabs repository. It models a 2.7B pi-class policy across hardware. One honesty note carried from the paper itself: most rows are model projections, validated on one card, an RTX 4090, where real runs reach 73.3 to 82.6 percent of the modeled speed. The measured row below is the exception.

Duty cycle falls straight out. A 10 Hz control deadline needs one call every 100 ms. On the 4090 row, at 31 ms per call, one robot occupies about 31 percent of one card: one card carries about three robots in sync mode. On Thor, at 52.6 ms, one robot takes 53 percent of the module, roughly one robot per module with room left for slower reasoning.

The worked basis on this page uses the optimized per-call time of 39 ms from the published break-even analysis. At 2,160 calls an hour:

GPU seconds per robot hour  =  C x t
                              2,160 x 0.039  =  84 seconds

duty per robot               =  84 / 3600    =  2.3 percent
robots per card, fully packed =  about 42

One robot hour of policy inference needs about 84 seconds of GPU time. That is 2.3 percent duty, room for dozens of robots on one card. This is why per-robot-hour costs can sit far below card prices, and why an operator's packing decision changes its unit economics more than any hardware choice.

Electricity, for completeness, never decides it. Eighty-four seconds at a 450 W board is 0.0105 kilowatt-hours, which at the 2026 United States residential average of about 18 cents per kilowatt-hour, per the EIA Short-Term Energy Outlook, is a fifth of a cent per robot hour. Even the on-robot alternative, a Thor-class module drawing 40 to 130 W, burns one to two and a half cents an hour at the wall. Power is noise in this budget, which every serious TCO analysis in the claims table agrees on.

The floor: what raw card time costs per robot hour

Set the per-call rate aside. What does bare card time cost, if you rent and manage everything yourself? Named parties, rates read 26 October 2026.

The Salad tiers came off the public pricing page: a 24 GB 3090 runs 0.090 at lowest priority to 0.170 at high, with 3060-class cards listed from 0.015. The RunPod row is the pods page read the same day. Spheron's figure is marketing math from their own deployment guide, for GR00T N1 on an H100, at rates they date to May 3, 2026. Viam's meter is on their pricing page.

The spread is the story. Raw card time at full packing is fractions of a cent. A self-managed setup on a rented H100 lands near 2. Per-call lanes land at 2.16 to 6.48, buying a served, warm, managed route with no idle card bill. A general platform meter bills 9.00 for a full hour of continuous compute. Every step up the ladder buys something you would otherwise do yourself: keep the model loaded, watch it, restart it, and pay for the card around the clock whether robots call or not.

The only priced robot API from a major cloud meters tokens, not calls: Google's Gemini Robotics ER 2 lists input at 1.00 per million tokens through the end of 2026, per Google's pricing page. A token price cannot be compared to a robot hour without the token count of a policy call, which none of these vendors publish. Physical Intelligence opened a hosted fine-tune and inference gateway to beta on October 13, 2026, with no public pricing, per their announcement. The per-call, per-robot-hour ground this page works is unoccupied.

Break-even: paying per call versus owning the card

When does your own card win? The crossover in robot hours per month, from the published break-even analysis, run here at this page's rates.

crossover Rh*  =  ( G / A + idle )  /  ( C x P )

G: card cost. A used RTX 3090 ran 1,150 to 1,400 on September 2026 trackers; this table uses 1,200.
A: amortization months, twenty-four.
idle: about 8 per month for a box left on, at 60 W and 18 cents per kilowatt-hour.
C x P: your hosted cost per robot hour.

At the pi0.5 class rate, a used 24 GB card breaks even near nine robot hours a month. Below that, paying per call is cheaper, before you count a single hour of your own setup and maintenance time.

Three duty profiles make the shape concrete. All use 6.48 per robot hour and one used card at 58 a month, idle on.

The rented middle path closes the triangle. A 3090 at Salad's lowest tier is 65.70 a month always-on at 730 card-hours. Dedicated to one robot that is absurd: you pay for a whole card and use 2.3 percent of it. Packed with forty-plus robots it is the lowest-cost serving basis on this page, and it is exactly what the duty math above says a card can hold. The labor and the standing software to keep that packing real are what a per-call rate buys. Where inference should physically live, on the robot or beside it, is its own guide.

What measured means here

The title says measured. Here is exactly what each class of number on this page is.

Nothing on this page is a wall-clock measurement of a live hosted route. The 6.48 is a derivation from published inputs. That is a stronger basis than any figure in the claims table, none of which shows its inputs at all.

A scale check

If the 2035 humanoid shipment forecasts hold, and one percent of those robots run hosted action loops eight hours a day at this page's lane rates, the action-inference market is on the order of a billion dollars a year. That is an estimate from October 2026 forecasts, not a projection by this platform. Its point is narrower: the slice this page prices is small today and structurally large in every serious forecast.

Re-run this on your numbers

Four inputs, one formula, no code.

1. Your frame rate and chunk length give calls per robot hour: 3600 x frame rate / chunk.
2. Your rate per call comes from the fence above or any rate card you trust.
3. Multiply. That is your cost per robot hour.
4. Divide your card's monthly cost by the result. Below that robot-hours count, pay per call. Above it, buy the card.

The full local side, with amortization, idle power, and three worked profiles, is the VLA break-even guide. The budget question for a whole robot program, integration and all, is the robot startup infrastructure cost guide.

Frequently asked questions

Is 6.48 per robot-hour what I will pay?

It is what the arithmetic yields on the stated basis: 2,160 calls per robot hour at the written-record rate for the pi05 model id. Your loop changes the call count, your model changes the rate, and the row is not on the public list as of 26 October 2026, so no live rate is quoted here. The method, not the number, is the durable part. The listed rates for every listed lane sit on the pricing page.

Why do other pages say a robot costs 17 to 24 per hour?

Because they price something else. The 17 to 24 figure is the cost of running a data factory with teleoperators, a lease, and depreciation, spread over its robot hours. Its own compute line is 2 to 3 million a year inside a 14.5 to 15.5 million total. The claims map above places every circulating figure, from 2 to 35, against what it measures.

How many inference calls does a robot make per hour?

Divide 3,600 by the seconds one chunk covers. At 30 frames per second with chunks of 50, one call covers 1.7 seconds of motion, so an hour holds 2,160 calls. Chunks of 15 at the same frame rate make 7,200. The pricing units guide works the unit in full.

What does the GPU itself cost per robot hour?

At full packing, fractions of a cent: one robot hour needs about 84 seconds of a card that rents for 0.090 to 0.170 per hour in community clouds today. Self-managed on a rented H100, a vendor's own worked example lands near 2. The gap between that floor and a per-call lane is the service: a warm model, managed software, and no idle card bill.

Does electricity matter?

No. A robot hour of policy compute draws 0.0105 kilowatt-hours on a 450 W board, a fifth of a cent at the 2026 residential average. An on-robot module draws under two cents an hour. Every TCO analysis in the claims table agrees power is noise next to utilization.

When is my own card cheaper than paying per call?

At this page's rates, above roughly nine robot hours a month on a used 24 GB card at the pi0.5 class rate, or roughly twenty-seven at the small-class rate. The crossover formula and three duty profiles are worked above. For most weekend builders the card never pays; for an always-on demo it pays eightyfold.

The derivation is the product: 2,160 calls, a published rate, dated hardware math, and the break-even tables to place them against. Listed rates for every listed lane sit on the pricing page. Sign up, create a key, and the only input left to fill in is your own loop.

Last verified: 2026-10-26