VLA local vs API: the break-even math

Running a vision language action model on your own GPU or paying a hosted route per call is a volume question, and the answer is arithmetic. This guide gives the crossover formula in robot hours per month. It turns your control loop into calls per hour using the action chunk, the unit that frame counting overstates fifty times at thirty frames per second. Both sides price from dated public sources: street prices, manufacturer power, government electricity, public benchmarks. This platform's action lane is not on the public list; the pricing page carries the listed rows' rates. The framework works on any rate card.

All amounts are United States dollars written as bare numerals; electricity in cents per kilowatt-hour. No rate for this platform's own models is typed by hand below; the rate card owns those numbers, and the formula section renders them live.

The decision in one number

The decision lands on one number: robot hours per month, the hours the arm spends executing its policy loop. Below your crossover hosted is cheaper; above it the card pays for itself inside its amortization window.

Three inputs decide the crossover, and you own two. Your loop: frame rate and action chunk length set the calls in one robot hour. Your duty: hours per month the robot runs. The third is the per call rate, read off a rate card.

One honest limit. This platform's action route is not on the public list; its contract is published, and the action lane's page describes it. The pricing page carries the listed rows' rates, and the rate here is your input.

What ranks for this question, and why none of it answers it

The results page is strong; none of it hands you a dollar figure. The top result is How Fast Can I Run My VLA? (February 2026), with a free tool, vla-perf, that models inference latency across data center GPUs, an RTX 4090, the Jetson family, and network links. It is the authority on where inference should live, with no prices. An August 2026 GPU benchmark post picks cards for the 10 Hz control deadline, never converting a number into money. The forum threads guess at ladders from 500 to 30,000 and argue bandwidth. The dollar question is unowned. This page answers it.

What one VLA call costs to serve

A vision language action policy does not return one movement. It returns an action chunk: a run of joint targets computed in one forward pass, which the arm works through while the next chunk computes.

Published latency anchors, to size your own loop:

Two things follow. The same card runs the same model two to three times faster with better serving software, so latency is a software fact as much as a hardware one. And the chunk makes 30 frames per second cheap: the October 2025 paper Running VLAs at Real-time Speed ran a pi0 class multi view policy at 30 Hz on one consumer GPU, catching a falling pen in under 200 ms end to end.

Calls per robot hour equals 3,600 times your frame rate, divided by your chunk length.

Counting frames instead of chunks overstates a hosted bill by exactly fifty times in the first row. The camera hands you frames; the bill counts chunks.

What can a call cost at the floor? An 80 GB H100 rents at 3.49 per hour on a major rental marketplace, read October 2026. At the measured 44.2 ms per call, that card computes about 81,450 calls per hour at full duty, so raw card time is about four thousandths of a cent per call. A per call price buys standing service: a warm card, current software, and nothing owed for the 97 percent of the time your robot is idle. A robot hour at 2,160 calls and 39 ms per call needs 84 seconds of GPU time, 2.3 percent duty: room for dozens of robots per card. The worked cases use that multiplier.

This platform's published route bills one call per served request, and the answer carries the action chunk plus the normalization block for your embodiment. The contract is at the run-action reference. Two budget facts from it: a request turned away before it is served costs nothing, and a retrying client pays twice, because this route does not replay.

The local bill: card, power, and the 24 GB cliff

The local side has three cost pieces, the hardware, the power it draws, and the price of that power.

Memory is the gate. The official LeRobot compute guide groups the families by training memory need: ACT roughly 2 to 6 GB, SmolVLA 10 to 16 GB, the pi0 and pi0.5 family 24 to 40 GB, tight on a 24 GB card at batch size one. The exception is priced in seconds, not errors: in the August 2026 benchmark, one flow matching model with a footprint over 24 GB ran on a consumer 24 GB card by spilling into system memory, and its latency went from 294 ms to 10,234 ms. The model still ran. The robot had already failed. An October 2026 forum report has a 16 GB MacBook Pro attempt forcing a restart before one inference completed.

Those families map onto this platform's action lane: the pi0.5 class as pi05 with its embodiment variants, the small class as SmolVLA, the single step cautionary row as openvla-oft, and the arm-native flagship as molmoact2-so100-101. None are on the public list.

Hardware, at dated reads. A used RTX 3090, the value floor for 24 GB, sold near 1,000 at September 2026 listing averages; a second market guide read the same card near 700 that month. A new RTX 5090 starts at 1,999 at list; October 2026 street prices sit far above: a 4,299 promotion sold out fast, and a tracker logged the lowest listing at 5,199 entering September. The on-board option is the Jetson AGX Thor developer kit: 128 GB at 40 to 130 W. NVIDIA repriced the Jetson line in July 2026, and its own developer price table now lists this kit at 5,499, up from 3,499 at launch.

Power, from the manufacturer. The RTX 3090 page lists graphics card power at 350 W with a 750 W system supply. The RTX 4090 page lists 450 W total graphics power and an 850 W supply. The worked cases use the board numbers; sustained inference sits near the full figure.

Electricity, from the government. The EIA Short-Term Energy Outlook puts the 2026 United States residential average at 18.2 cents per kilowatt-hour, up from 17.3 in 2025. Your bill is the number that matters.

At 2,160 calls per robot hour and 39 ms per call, one robot hour burns 0.0105 kWh on a 450 W box, 0.19 cents of electricity. Electricity is a rounding error; amortization decides. The forgotten line is idle: an always-on box at a 60 W idle estimate burns 7.9 a month, a sixth of a weekend robot's local bill.

The break-even formula

hosted cost per month  =  Rh x C x P

local cost per month   =  G / A  +  W x 720 x U / 1000  +  Rh x C x t x E x U / 3600

crossover Rh*          =  ( G / A  +  W x 720 x U / 1000 )  /
                          ( C x ( P  -  t x E x U / 3600 ) )

The named variables:

• Rh: robot hours per month. Rh* is the crossover, where both sides cost the same.
• C: calls per robot hour, from the chunk table above: 3,600 x frame rate / chunk length.
• P: hosted rate per call, from the live table or any rate card.
• G: hardware cost. 1,000 for the used 3090 tier, 1,999 list for the 5090, zero if the box already exists.
• A: amortization months; this guide defaults to twenty-four.
• W: idle watts, if you leave the box on. Zero if you switch it off.
• t: GPU seconds per call, from the latency table; 0.039 on the optimized kernels.
• E: wall draw in kilowatts while computing; 0.45 for the 4090.
• U: electricity price in dollars per kilowatt-hour. 0.182 is the 2026 national average.

The loop-to-bill arithmetic, for your own inputs:

FPS, CHUNK = 30, 50          # your control loop
HOURS = 160                  # robot hours per month
RATE = 0.001                 # assumed rate per call, your input

calls_per_hour = 3600 * FPS / CHUNK          # 2,160 on these inputs
hosted_month  = calls_per_hour * HOURS * RATE
gpu_seconds   = calls_per_hour * 0.039       # 84 s of card time per robot hour

One rule falls out: the electricity term is about a millionth of a dollar per call, so ignore it. The crossover is amortization divided by rate, moving inversely with rate and chunk length, which is why the chunk column matters more than any headline latency.

No public per call rate card exists yet for these robot models anywhere, so the worked cases mark their rate columns as assumptions, not quotes.

Three worked cases

Every case uses the same loop: 30 frames per second, chunk of 50, 2,160 calls per robot hour. Local: the used 3090 at 1,000 over 24 months is 42 monthly, plus 8 idle if left on; Thor and 5090 rows use their dated prices.

At one cent per call the 3090 crossover is under 2 robot hours a month: almost nobody should own a card for cost alone.

The weekend arm. A hobby SO-101 class arm running two hours a week is about 9 robot hours a month. Hosted at a tenth of a cent: about 19; at a hundredth, 1.9. Local on the used 3090 with idle: about 50, mostly amortization on a dark box. Hosted wins three to twenty-six times over. If you already own the card, G is zero and hosted competes on convenience.

The lab bench. Eight hours a day, five days a week, is about 160 robot hours monthly. Hosted at a tenth of a cent: 346; local about 50, so the card wins sevenfold. At a hundredth, hosted costs 35 against the card's 50 and wins. For labs the answer sits inside the rate uncertainty; wait for a real rate card. The evaluation guide covers the benchmark side.

The always-on robot. A demo arm running 24 hours a day is 720 robot hours a month. Hosted at a tenth of a cent: 1,555 per robot per month. Local: about 51, with room for many more robots at 2.3 percent duty each. Local wins thirtyfold at a tenth of a cent, threefold at a hundredth. Here owning becomes an architecture decision.

The rented middle path. An 80 GB A100 at 1.59 per hour, or an H100 at 3.49, never becomes hardware. It beats owning for weeks-long projects and loses once your duty fills a card: 160 robot hours a month costs 50 on your own 3090, 254 rented on an A100. Rent for bursts. Buy for schedules.

When local wins honestly

Cost is one axis. Three others decide real projects.

Privacy and data boundaries. Cameras in a home, a clinic, or a factory floor stream exactly what a policy needs to see. If that video cannot leave the site, the per call rate is irrelevant and local wins at any volume.

Air gaps and connectivity. A robot with no reliable uplink cannot depend on a remote policy, whatever it costs. Warehouse and field work, where the network is the least reliable part of the loop, says the same.

Bandwidth ceilings. Three views at high resolution pushes a weak uplink hard. If the uplink is the constraint, the physics decides before the money does.

The honest reverse: local means you own a serving stack. Memory fit, serving software, driver versions, and the silent spillover cliff become your weekly problems. The forum ladder of 500 to 30,000 exists because buyers guess without a crossover number. This page is that number. Where inference should physically live is its own guide.

Frequently asked questions

Is it cheaper to run a VLA locally or call an API?

One number: robot hours per month. Multiply calls per robot hour by the per call rate and compare against the card's monthly amortization plus idle power. On this guide's dated anchors, a used 1,000 card at 24 months breaks even near 19 robot hours a month at a tenth of a cent per call, near 193 at a hundredth. Electricity never decides it.

Should a VLA run on-device, on Jetson-class hardware, or offloaded to the cloud?

That is a latency and architecture question before a cost question, and Google's related questions ask it in almost those words. The physics is layered, and the Jetson versus cloud guide works it in full; the cost answer is this page's formula.

What control frequency does a VLA actually need?

The August 2026 benchmark names the deadline: an arm catching a falling object replans every 100 ms, so 10 Hz, and a humanoid on stairs wants 50 Hz or faster. Chunking changes the billing question: the model must answer before the current chunk runs out, not every frame. At 30 frames per second and a chunk of 50, one call covers 1.7 seconds of execution.

How fast can I run my VLA?

Faster than the papers implied a year ago. The October 2025 real-time paper and its kernels answer a pi0.5 class call in 22 to 39 ms on an RTX 4090 depending on camera count, while the official unmodified configurations run two to three times slower on the same card. Your serving software is half the answer.

How much GPU memory does a VLA need?

For training, the official LeRobot compute guide gives the envelopes: 2 to 6 GB for the ACT class, 10 to 16 GB for SmolVLA, 24 to 40 GB for the pi0 and pi0.5 class. Serving usually needs less. Exceeding your card's memory does not error out; it slows by thirty times or worse.

How many API calls does a robot make per hour?

Divide 3,600 by the seconds one chunk covers: chunk length over frame rate. At 30 frames per second: a chunk of 50 is 2,160 calls per robot hour, a chunk of 15 is 7,200, and a single step policy at its measured 5.8 Hz ceiling is about 20,900.

How much do AI robots typically cost?

Split the question: the brain and the body have separate budgets. A SO-101 class arm is a parts-and-printing cost in the low hundreds. The brain is this page's subject: zero if you own a gaming PC, about 1,000 for a used 24 GB card, 5,499 for a robot-class 128 GB developer kit. A humanoid is a different budget class.

Which price point should I buy for local VLA work?

The ranking thread lists machines from 500 to 30,000; the honest answer collapses most of that ladder. Under 24 GB: the small policy classes. At 24 GB: the pi0.5 class, tightly. Above that: headroom for bigger checkpoints or more robots. If your monthly robot hours sit under your card's crossover, do not buy at all: rent for bursts, or wait for a rate card.

Rates and metering units for every listed lane sit on the pricing page, and the action lane's model set on the models page. Sign up, create a key, and this guide's loop needs one line changed, the address.