Robot fine-tune and eval product math: the 2.08 loop

A packaged robot policy product has two legs. Train the policy, then prove it with a counted evaluation report. The measured loop cost 2.08 to produce in October 2026: 0.1497 to train a pi 0.5 class policy for 15,000 steps, and 1.9344 for the 500-episode LIBERO report. Both ran at 0.041 per card-hour on rented 24 GB cards. The written charge band for such a report is 15 to 40. The whole loop sits at 7.6 percent of that band's midpoint, and at 13.9 percent of its floor. No vendor publishes a price for the loop. Every public bill prices training alone. This page shows the full arithmetic in static tables you can check with a pencil.

All amounts are United States dollars written as bare numerals. Every table is static. Nothing on this page needs a script to check.

Last verified: 2026-10-26

The answer in one line

loop cost  =  T + E

T:  train cost   =  train wall hours  x  card-hour rate
E:  report cost  =  report wall hours x  card-hour rate

The measured run, every number an input:

The math inverts, and that is the check. The report alone bought 258 episodes per dollar at this basis. Its own table reads 482 successes out of 500 episodes, 96.4 percent. The evaluation cost page owns that wall clock in full. This page owns the product math. It answers what the two legs cost together, and what the market charges for pieces of them.

What the loop is, and the bill everyone else prints

A working policy is not a training run. It is a loop. Collect demonstrations, train, evaluate on a counted benchmark, read the report, then decide what to collect next. The bill for that loop has five lines.

The closest public bill to this comes from AY-Robots, a training platform, in a cost teardown published 23 August 2026. It prints four lines. GPU time at 1 to 12 per run, and you will do 3 to 5 runs. The robot at 110 to 500 EUR, once. Human hours at 1 to 4 per dataset. And waste, unbounded. It is an honest bill for what it covers. It prices training only. The evaluation line is missing. That line is the expensive one. The measured report cost 12.9 times the measured fine-tune it judged.

That gap is the reason this page exists. Here is the market state for the loop. Every party named, every price dated, all checked today.

Read the pattern across the table. The oldest entrant prices training. The two newest entrants look exactly like the loop, and both sit behind a waitlist and an invite door. Not one publishes a price for train plus report. The price column is empty on the evaluation side. Measured numbers below show that is the column that matters.

The train side, measured

The measurement trained a three-step ladder on rented RTX 3090 class cards. Each card has 24 GB of memory, 10 vCPUs, and 32 GB of RAM. The library was LeRobot, pinned at 0.6.1. Every wall below is a recorded job, not an estimate. Rates first, then walls.

The rate basis, in plain words. The run's owner paid a below-list batch rate at the community cloud: 0.041 per card-hour. That cloud's own pricing page says volume and long-running work is priced below its published tiers. The basis is a named program at a named cloud, not an invention. A member of the public renting the same card class today pays 0.090 per hour at the lowest public tier. The page re-prices every wall at public rates later. Nobody should mistake the run basis for a checkout price.

Two findings in that table decide real budgets.

First, the middle rung is the load-bearing one. It runs on a cheap card only because of a documented trade. The official pi 0.5 recipe is sized for one 80 GB card at batch size 64. The library also ships a reduced-memory variant. It freezes the vision model and trains only the action expert. The docs say plainly what that costs: less memory, at some cost in success rate. The measured run took that variant at batch size 2 on 24 GB. It finished 15,000 steps in 3.65 hours, at 1.195 steps per second. The report then showed what the trade bought: 96.4 percent aggregate success on LIBERO. A competitor's catalog lists the same model class at about 4 to 12 a run, because it rents 80 GB cards for the full recipe. Both numbers are true. They price different modes. The mode is a budget decision.

Second, memory is the pricing boundary, not speed. The 5B rung did not run slow. It refused. LoRA died out of memory at batch size 1, and so did the frozen mode. That is eight attempts, four per arm: the LoRA arm after the weights had loaded, the frozen arm at load itself. The model's own project sets the pattern. Its openpi requirements table puts LoRA fine-tuning above 22.5 GB, and full fine-tuning above 70 GB. LeRobot's compute guide calls 24 GB cards tight for the large classes even at batch size 1. A 5B fine-tune prices at the 40 GB and up tier, full stop. That tier starts near 1.79 per card-hour at a mainstream pod provider today. The community 24 GB class starts at 0.090. The memory boundary is a twentyfold rate step.

The report side, measured

The evaluation leg has its own full page, the 1.93 per 500-episode report. The figures carried here agree with it exactly.

Two properties of this leg drive the product math. The wall is reset-bound, not card-bound. The simulator rebuilds its scene between episodes. That is about 5.8 minutes of wall per episode, all included. The rollout itself runs 23 to 83 seconds. And the wall is the cost. At a fixed rate, episodes times minutes sets the invoice. A bigger card barely moves it. Both findings are worked in full on the report page, with the restart story. The run survived two interruptions because it ran in 25-episode chunks with saved progress. A cold re-run without that design costs about half again as much wall.

The product math in the open

Now the two legs as one product. Symbolically first, then with the run's numbers.

loop share of band  =  (T + E) / B

B:  the charge band for the packaged report, 15 to 40
    midpoint 27.50

T + E  =  0.1497 + 1.9344  =  2.0841

2.0841 / 15.00  =  13.9 percent   (floor of the band)
2.0841 / 27.50  =   7.6 percent   (midpoint)
2.0841 / 40.00  =   5.2 percent   (ceiling)

The train leg alone has its own written band, 25 to 60 for the big class. Its measured cost, 0.1497, sits against a 42.50 midpoint. That is about 0.35 percent. The report leg is the one that carries margin pressure. It is also the leg nobody prices.

What the band is, in plain words. A number without provenance is a mood. The 15 to 40 band is this platform's written charge plan for a packaged 500-episode report. It was set on 4 October 2026, anchored to the market parties named above: the raw card counters, the per-run training claims in public, and the credit plans around them. The anchors put a fair packaged charge in that range. The band was written before the measurement, then tested against it. Nothing packaged is on sale here today, 26 October 2026. This page is the math, not a checkout.

The test is one sentence, and it generalizes to any service product. A packaged offer clears only when its measured cost of production sits at or below one fifth of the charge band's midpoint. That twenty percent line, applied to the measured numbers:

The verdicts clear at the run basis, with room. The honest counter-case is the public-counter basis, worked next. There the margin thins to nothing at the top of the card market. Both are shown. A page that shows only one basis is selling something.

The same loop at public counters

Take the measured walls: 3.65 hours of training, 47.18 hours of reporting. Buy those hours at every public counter, read on 26 October 2026.

Rates: the Salad pricing page, the RunPod pods page, and the Hugging Face GPU table. Each was read on the date above. The spread across one page of counters is a factor of 28 for the identical walls.

Two readings matter more than the spread. At the community tier, the whole loop costs 4.57 in raw card time. The written band clears it with room. At the top of the managed market, the same loop costs 127.08 in raw card time. That is above the entire band. A service built on premium cards cannot price a 15 to 40 report at that counter and survive. Where the hours come from is the product's first design decision. Then read the fine print on the cheap managed rows. The Hugging Face A10G small card ships with 4 vCPUs and 15 GB of RAM. A report leg that is CPU-bound in scene rebuilds will run slower behind a thin CPU slice. When you rent for evaluation, buy the CPU alongside the card.

The lines the math leaves out

The tables above price card hours. Three real cost lines do not appear in them. The measured program met all three.

The first is the storage ceiling. A 15,000-step run that saves every 1,000 steps makes 15 checkpoints. At about 11.55 GB each, that is about 173 GB. A free private tier at the model hub holds 100 GB, per their storage limits document. One such run overflows it by itself. The measured program hit this repeatedly, at checkpoint pushes and again at the final model push. Deleted blobs only free quota after about a day and a half. The fixes are cheap, and each costs something else. Keep checkpoints on the machine and push only the final model. Push checkpoints to public storage where policy allows. Or buy the 1 TB paid tier, which holds about 86 checkpoint sets of this size. Pick one before the run, not during it.

The second is the checkpoint push tax. Pushing each checkpoint to the hub, as insurance against interruption, took 12 to 17 minutes per interval on the big rung. Training an interval took about 12 minutes. Saved-everywhere roughly doubles the training wall. The insurance is real, and it is not free. Space the saves out, and a crash costs more work. Push everything, and the wall doubles. No setting removes the choice.

The third is the restart tax. Interruptions happen. In one 40-hour window, the measured report lost a node once, and the provider's credit system once. A run built in chunks with saved progress absorbs both as delays. A run built as one long job pays about half again as much wall on a cold restart, plus 80 minutes of machine setup. The chunked design is the difference between an inconvenience and a lost week. It costs nothing but the discipline of small pieces.

None of these three lines change the 2.08. They change the odds that 2.08 is what you actually pay.

What measured means here

The one figure here that is not a firm price, the 4 to 12 per-run claim, is labeled an estimate by the party that publishes it.

Budget your own loop

The recipe, all of it from numbers above.

1. Pick the mode before the card. The full recipe for a 3B class policy wants an 80 GB card. The frozen-vision variant fits 24 GB, and the official docs name the trade. For the 5B class, start at 40 GB. A 24 GB card refuses it at any batch size.
2. Price the train leg from walls, not card speed. Steps divided by steps per second, plus setup. The measured middle rung: 3.65 hours for 15,000 steps.
3. Price the report leg from episodes and the reset clock. Episodes times 5.8 minutes is the honest planner for CPU-side LIBERO. Four hundred episodes, the published shape, is about 38 hours. The measured 500 was 47.18.
4. Check what your episode flag means on your library version. On the pinned 0.6.1 it counted per suite. A 500 request meant 2,000 episodes, about 8 days. Today's docs describe it as per task. Print the plan before the long run.
5. Run the quick check first. Forty episodes, four hours or less, catches the wrong checkpoint while the mistake is cheap.
6. Choose storage before the first checkpoint. Local plus final push, public repos, or a paid tier. Do not discover the 100 GB ceiling at hour eleven.
7. Compare any quote you receive against the market table above. Then ask the one question it cannot answer today: what does the report cost?

Frequently asked questions

What does the fine-tune and evaluation loop cost?

At the measured basis, 2.0841, written 2.08. Training a pi 0.5 class policy for 15,000 steps cost 0.1497. The 500-episode LIBERO report cost 1.9344. Both ran at 0.041 per card-hour on rented 24 GB cards, October 2026. At public counters read today, the same walls cost 4.57 at the community tier floor, up to 127.08 on premium managed cards. The basis moves the number, not the arithmetic.

Why does the evaluation cost more than the training?

Because the report is bound by the reset clock, not the card. Each LIBERO episode pays about 5.8 minutes of wall. Almost all of it is the simulator rebuilding its scene. Training, by contrast, computes 1.195 steps every second on a quiet GPU. The report cost 12.9 times the fine-tune it judged. Every public bill that omits the evaluation line omits the bigger number.

Can I buy the loop as a product today?

Not from anyone we could find, and we looked on 26 October 2026. The closest shapes: a managed fine-tune beta behind a waitlist, with no published price. A fine-tune-and-compare platform behind an invite door, with no pricing page. And a training service that prices runs but sells no report. This platform's own packaged band is a written plan, not a live offer. The pricing page carries every lane that is on sale today.

What is the 15 to 40 band, and who set it?

It is this platform's written charge plan for a packaged 500-episode report. It was set on 4 October 2026. The anchors are public card rates and the per-run training claims in the market table. The band was written first, then tested against the measurement under the twenty percent line. A packaged offer clears only when its measured cost of production is at or below one fifth of the band's midpoint. The measured loop clears it at 7.6 percent of the midpoint.

Why does the 5B class cost a different tier?

Memory. The measured program put a 5B LoRA fine-tune on a 24 GB card, and the card refused it. Out of memory at batch size 1, in both available training modes, eight attempts. The model project's own floor for its 3B neighbor is above 22.5 GB for LoRA and above 70 GB for the full recipe. LeRobot's compute guide calls 24 GB tight even for that neighbor. So the 5B class prices at the 40 GB and up tier. That tier rents for roughly twenty times the community 24 GB rate today.

How do I re-run this math on my numbers?

Four inputs and one formula. Your train wall: steps divided by your measured steps per second. Your report wall: episodes times minutes per episode, at about 5.8 for CPU-side LIBERO. Then the card rate: any row of the counter table, or your own. Loop cost is the two walls times the rate, plus the storage and restart lines from the hidden-cost section. Every table on this page is static, so you can check it with a pencil.

The loop is the product. It has a 2.08 measured cost of production. It clears a written 15 to 40 charge band with room. And the market still prices only half of it. The evaluation report page owns the report wall. For the serving side, see the robot-hour derivation. The pricing page carries every lane on sale today. Sign up, create a key, and the first thing worth pricing is your own loop.

Last verified: 2026-10-26