![Nvidia Flora Estimates $0.72 per Video Hour [2026]](https://shattered.io/wp-content/uploads/2026/10/nvidia-flora-robot-video-labeling-72-cents-gpt-6-astra-2026-gen.webp)
NVIDIA’s open-source Flora suite can label an hour of robot video for an estimated $0.72, according to the project’s own repository on GitHub. The same repository puts GPT-6 Astra, run at its highest reasoning effort, at roughly 125 times that cost. Coverage of a reported 50-video test lists the two prices as $0.72 and $88.49 per video hour, which is where the $88.50 figure in headlines comes from.
Those numbers are projections, not invoices. The repository builds its $0.72 from a rental assumption of eight GB300 GPUs at $10 per GPU-hour, and no outlet has shown a production bill. Anyone treating the headline as a measured, real-world price is reading more into it than NVIDIA wrote. The story still matters, because it shows how fast the cost of turning raw robot footage into training data is falling.
This is a robotics and AI-infrastructure story, not a console or PC release, so it sits at the edge of our gaming desk. It earns a place here because it hinges on GPU rental pricing, the same market that shapes graphics card supply for players. Our earlier look at Enact Intelligence raising $30M to give robots touch covered another piece of the same robot-data pipeline, and the wider gaming section tracks the hardware economics behind it.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
What NVIDIA Flora Actually Is #
Flora is described in NVIDIA’s repository as an open-source model suite and data engine. Its job is to turn videos of robots and humans manipulating objects into labels that other systems can learn from. Those labels include action segmentation, captions, and an assessment of outcomes and rewards.
The repository names three components: Flora-TempSeg, Flora-Captioner, and Flora-Rewarder. Each handles a different stage of the labeling job. TempSeg cuts a long video into meaningful segments, Captioner describes what happens in each segment, and Rewarder judges whether the action worked. Together they replace a task that robotics teams have usually split between human annotators and general-purpose vision-language models.
The open-source part is the strategic detail. Teams can run the suite on their own hardware instead of sending footage to a hosted API. That changes the cost structure, the privacy picture, and the speed at which a lab can iterate on its own data. It also explains why NVIDIA, which sells the GPUs, has a clear interest in publishing the code.
The $0.72 and $88.50 Figures, Line by Line #
The repository’s cost estimate is $0.72 per hour of video. It rests on a specific assumption: eight GB300 GPUs priced at $10 per GPU-hour. The comparison point is GPT-6 Astra at its highest reasoning effort, and the repository says Flora comes out approximately 125 times cheaper.
Coverage of NVIDIA’s test lists the Astra figure as $88.49 per video hour, against $0.72 for Flora. The Decoder, which ran a piece headlined around Flora being 125 times cheaper than GPT-6 Astra, framed the result as coming from NVIDIA’s own estimates. The German outlet ad-hoc-news used the word rechnerisch (computed) when it described the $0.72 hourly figure, which signals the same reading: a calculation, not a receipt.
The table below lays out what the sources say and how firmly each number is backed.
| Item | Figure | Status |
|---|---|---|
| Flora cost per video hour | $0.72 | Estimate from NVIDIA’s repository |
| GPT-6 Astra cost per video hour | About $88.50 ($88.49 in test coverage) | Projection at highest reasoning effort |
| Stated cost gap | Approximately 125x | Repository’s rounded claim |
| Hardware assumption | Eight GB300 GPUs | Modeled, not measured |
| GPU rental assumption | $10 per GPU-hour | Modeled, not measured |
| Reported test size | 50 videos | NVIDIA-reported |
| Annotation quality | 57.1% Flora vs 53.7% Astra | NVIDIA-reported |
Two details stand out. First, the cost figures and the quality figures all come from NVIDIA’s side of the table, so no independent lab has confirmed them. Second, the dollar numbers describe compute only. They say nothing about storage, engineering time, orchestration, or the people who review the output.
How the 125x Gap Is Built #
Divide $88.49 by $0.72 and you get about 122.9. The repository rounds that to approximately 125 times. The difference is small, and it doesn’t change the conclusion, but it shows the headline multiple is a rounded marketing-friendly number rather than a measured ratio. Readers who quote 125x should say approximately, and readers who want precision should use roughly 123x from the two published dollar figures.
What the eight-GPU assumption implies
Here is our own arithmetic, not a figure from NVIDIA. Eight GPUs at $10 per GPU-hour cost $80 for each hour the cluster runs. If Flora costs $0.72 per video hour, the cluster would need to process about 111 hours of video in each hour of wall-clock time to hit that price. That is a throughput claim hiding inside a cost claim. Anyone who plans to reproduce the number should measure real throughput on their own footage first, because the price scales directly with how many video hours the hardware clears.
Why the Astra number is a projection too
The $88.50 side of the ratio is also modeled. The repository prices GPT-6 Astra at its highest reasoning effort, which is the most expensive way to run it. A lab that used a lower reasoning setting, or batched requests, or negotiated enterprise pricing, would see a smaller gap. Our Claude versus GPT comparison of Opus 5.5 and GPT-6 Sol shows how much effort settings and agent workloads can move the bill within the GPT-6 family.
The 50-Video Test: 57.1% vs 53.7% #
Reports say NVIDIA ran a test on 50 videos and found that Flora reached 57.1% annotation quality against 53.7% for GPT-6 Astra. That is a lead of 3.4 percentage points. It is a real edge on paper, but it is a modest one, and 50 videos is a small sample for a claim about labeling robot footage in general.
The more interesting reading is not that Flora beats Astra. It is that a smaller, specialized, open model lands in the same quality band as a frontier model at a tiny fraction of the cost. If the quality gap had run the other way by ten points, the price advantage would matter far less. Because the two are close, the price becomes the deciding factor for any team labeling thousands of hours.
The Decoder’s coverage adds a useful nuance. Its section headings say Flora finds actions better, while Astra often describes them more precisely. That fits what you would expect from a purpose-built segmentation and reward pipeline against a general model with strong language skills. A team that needs rich natural-language captions may still prefer a frontier model for that single step.
What we can’t say is how the 57.1% score was defined, how the 50 videos were chosen, or whether outside researchers can reproduce it. The fact sheet we worked from does not describe the scoring method. Until independent groups publish their own runs on their own footage, treat the quality figures as a vendor claim with a clean, plausible shape.
Why Robot Video Labeling Is a Bottleneck #
Robots learn from demonstrations. A humanoid or arm that folds a towel, stacks a box, or opens a drawer needs thousands of examples where each example is broken into steps, described in words, and marked as success or failure. Collecting the footage is getting easier because cameras are cheap and teleoperation rigs are spreading. Labeling it is the slow part.
Human annotators can do the work, but they cost money and time, and their consistency varies. General-purpose models can do it faster, but at high reasoning settings the bill grows quickly, which is exactly the gap the Flora comparison targets. A tool that cuts the per-hour cost by two orders of magnitude, even if the real figure turns out to be several times higher than the estimate, would change which projects are affordable.
The market pressure is visible elsewhere in the robotics push. Tesla’s leadership has staked a large share of the company’s value on its humanoid program, a bet we examined in Musk Bets Tesla Value on Optimus. Every company building physical AI faces the same data problem, and every one of them would like cheaper labels.
Flora-TempSeg, Flora-Captioner and Flora-Rewarder Compared #
The repository lists three named components. The table below summarizes what each is described as doing, based on the repository’s own description of the suite’s outputs.
| Component | Role in the pipeline | Output |
|---|---|---|
| Flora-TempSeg | Splits video into temporal segments | Action segmentation |
| Flora-Captioner | Describes what happens in each segment | Captions |
| Flora-Rewarder | Judges whether the action succeeded | Outcome and reward assessment |
| Full suite | Chains all three on rented GPUs | Labeled training data, est. $0.72 per video hour |
The reward component deserves attention. Reward labeling is the step that tells a learning system whether a demonstration was good, and it is where general models tend to struggle with fine physical detail. The Decoder reported that almost no other model catches mid-episode errors, a point that favors a purpose-built rewarder. We did not confirm the underlying benchmark, so we treat it as a coverage claim rather than an established result.
Estimate Versus Production: What the Numbers Leave Out #
The repository’s $0.72 is a modeled cost, and the word modeled does a lot of work. A real deployment adds several expenses that a GPU-hour calculation skips. Teams pay for data transfer and storage of raw video, for the engineers who tune the pipeline, for quality review of the output, and for the idle time when the cluster waits on jobs.
Utilization is the biggest swing factor. The $10 per GPU-hour assumption works only if the eight GPUs stay busy. A lab that keeps them half occupied pays double per processed hour. A lab that already owns the hardware pays something different again, depending on how it accounts for depreciation and power.
- Utilization: idle GPUs raise the effective price per video hour in direct proportion.
- Review labor: a 57.1% annotation-quality score implies people will still check and correct output.
- Data handling: moving and storing raw footage costs money that the GPU-hour figure does not include.
- Engineering time: adapting an open suite to a lab’s own cameras and tasks takes staff hours.
- License terms: teams should read the repository’s license before building a product on it.
None of this makes the estimate dishonest. NVIDIA stated its assumptions in the open, and that is more than many vendor comparisons do. It does mean the 125x multiple belongs in the category of best-case planning figure.
Sensitivity: What Happens if GPU Rental Prices Change #
Because the $0.72 comes from a simple formula, we can test how fragile it is. The next table is our own arithmetic. It holds NVIDIA’s throughput implication constant, scales only the GPU-hour price, and compares each result with the $88.49 Astra figure from the test coverage.
| GPU rental price (per GPU-hour) | Flora cost per video hour | Gap vs $88.49 |
|---|---|---|
| $5 | $0.36 | About 246x |
| $10 (NVIDIA’s assumption) | $0.72 | About 123x |
| $20 | $1.44 | About 61x |
| $40 | $2.88 | About 31x |
The result is reassuring for NVIDIA’s argument. Even if real GPU prices or poor utilization quadrupled the cost, Flora would still sit about 31 times below the Astra projection. The advantage does not depend on the exact $10 assumption. It depends on the big structural difference between running a small specialized model and running a frontier model at maximum reasoning.
Scale the numbers up and the stakes become clear. At the estimated rates, 1,000 hours of video would cost about $720 with Flora against about $88,490 on Astra. A library of 100,000 hours would cost about $72,000 against roughly $8.8 million. Those are projections, but they show why a robotics team with a large archive would care.
Why This Story Reaches Gaming and GPU Readers #
The assumption at the center of the estimate is a GPU rental price. That puts the story squarely in the economics of AI hardware, a market that competes with gamers for silicon, memory, and attention. When labs find cheaper ways to use rented GPUs, demand patterns shift, and those shifts eventually reach graphics card pricing and availability.
Cloud capacity is already tight. Our report on Google Cloud’s A5X plan for 960,000 Rubin GPUs shows how large the next wave of rentable compute will be, and BofA’s projection of $2.1T in data center spending by 2028 sets the scale of the money chasing it. Flora is one example of software that gives all that capacity a concrete job.
There is a practical angle for hobbyists too. Open models that run on rented or owned hardware are the same family of tools that enthusiasts test on consumer cards. If you are weighing a graphics card for local AI work, our comparison of Nvidia versus AMD GPUs for local AI at 32GB versus 24GB covers the memory trade-offs. Flora targets data-center GB300 hardware, though, so it is not a consumer-card workload.
Competitive Context: Open Suites vs Frontier APIs #
The Flora pitch sets two philosophies against each other. On one side sits a frontier model such as GPT-6 Astra, reached through a paid API, flexible across tasks, and priced for its generality. On the other sits a narrow open suite tuned for one job, run on hardware the user controls, and priced close to the cost of the electricity and silicon it consumes.
| Factor | NVIDIA Flora | GPT-6 Astra (highest reasoning) |
|---|---|---|
| Licensing model | Open source, per the repository | Commercial model |
| Estimated cost per video hour | $0.72 | About $88.50 |
| Reported quality (50 videos) | 57.1% | 53.7% |
| Task focus | Robot and human manipulation video | General purpose |
| Where it runs | User-controlled GPUs (eight GB300 in the estimate) | Provider-hosted |
| Caption richness | Reported as less precise than Astra | Reported as often more precise |
NVIDIA’s other recent releases show the same pattern of selling a stack. Our coverage of NVIDIA OpenShell pinning AI agents to four silicon layers described a reference design aimed at keeping agents safe on its hardware. Flora fits that strategy: give the world free, useful software that happens to run best on the company’s chips.
Historical Context: From Human Annotators to Model Labels #
Machine learning has always run on labeled data, and the history of the field is partly a history of making labels cheaper. Early computer vision relied on armies of human annotators drawing boxes and tagging images. Later, crowdsourcing platforms spread the work across many workers at low per-item rates. More recently, teams started using large models to produce labels and then paying humans only to audit them.
Robotics lagged behind other fields because its data is harder. A single minute of manipulation video contains contact, timing, and cause and effect that a still image never shows. Labeling it well means understanding sequences, not just objects. That is why a temporal segmenter and a reward model, the two pieces Flora ships, are the interesting parts of the release.
The Flora estimate follows the same arc. The cost per hour of labeled video moved from human wages, to frontier-model API calls, and now to a specialized open pipeline priced as raw compute. Each step cut the price and shifted the bottleneck. After this step, the bottleneck moves toward verifying quality and collecting enough varied footage.
Market Impact: Who Gains and Who Loses #
The clearest winners are robotics startups and university labs. A team with a few thousand hours of footage and a small cloud budget can now consider labeling it in-house. That lowers the entry fee for physical AI, which matters because capital is concentrated in a few large players. The Enact Intelligence round we covered earlier is one sign that investors are funding the sensing and data layers of robotics.
NVIDIA benefits in a less obvious way. Every lab that adopts Flora needs GPU time, and the repository’s own estimate is built on GB300 hardware. The company gives away the software and sells the platform it runs on. That is a familiar playbook, and it has worked for NVIDIA in other categories.
The pressure lands on providers who earn revenue from high-reasoning labeling calls. If customers move bulk video annotation to open pipelines, the API vendors lose a high-volume, high-margin use case. They will likely respond with cheaper effort tiers, batch discounts, or their own specialized models. That competition, if it follows, helps buyers regardless of whether Flora’s exact numbers hold.
Human annotation firms face a squeeze too, though a partial one. Quality review stays necessary, and a 57.1% quality score leaves plenty of room for people in the loop. The work shifts from labeling every frame to checking and correcting model output.
Five Predictions for Robot Data Labeling #
These are our analysis, not reported facts, and each could be wrong.
- Independent tests arrive within weeks. Open code invites reproduction. We expect at least a few labs to publish their own cost and quality numbers on different footage, and those results will probably land below the headline advantage.
- The real gap settles well under 125x but stays large. Our sensitivity table shows the advantage survives even a fourfold cost increase, so a double-digit multiple looks plausible once overhead is counted.
- API vendors add cheaper video-labeling tiers. Pricing pressure from a free open suite usually forces a response, most likely through lower reasoning-effort options or batch rates.
- Hybrid pipelines become standard. Teams will probably use a specialized segmenter and rewarder, then call a frontier model only for rich captions, matching the strengths that The Decoder’s coverage describes.
- Quality review becomes the new line item. As labeling compute gets cheap, verification and data diversity take over as the costs teams worry about.
What to Watch Next #
Three things will tell us whether the Flora estimate holds up. First, whether outside groups reproduce the 57.1% versus 53.7% result on larger and more varied sets than 50 videos. Second, whether anyone publishes a real invoice for running the suite at scale, which would turn the $0.72 estimate into a measured number. Third, how GPT-6 Astra’s pricing and effort settings change in response.
The takeaway: NVIDIA has published a credible, openly assumption-driven case that specialized open models can label robot video far more cheaply than a frontier model at maximum effort. The $0.72 and $88.50 figures are estimates built on a $10 per GPU-hour rental price, the 125x multiple is rounded, and the quality test is small and vendor-reported. Read them as a planning signal, not a price list.
Frequently Asked Questions #
What is NVIDIA Flora?
Flora is an open-source model suite and data engine from NVIDIA. It turns robot and human manipulation videos into labels, including action segmentation, captions, and outcome or reward assessment. Its repository lists three components: Flora-TempSeg, Flora-Captioner, and Flora-Rewarder.
Does Flora really label an hour of robot video for 72 cents?
Not as a confirmed production cost. The $0.72 per hour is an estimate in NVIDIA’s repository, built on eight GB300 GPUs at $10 per GPU-hour. No source we reviewed shows a measured real-world bill, so treat it as a modeled figure.
How much cheaper is Flora than GPT-6 Astra?
The repository says approximately 125 times cheaper than GPT-6 Astra at its highest reasoning effort. Using the reported figures of $0.72 and $88.49 per video hour, the exact ratio is about 123. Both sides of that comparison are projections.
Is Flora more accurate than GPT-6 Astra?
In a reported NVIDIA test on 50 videos, Flora scored 57.1% annotation quality against 53.7% for GPT-6 Astra. That is a 3.4-point lead on a small, vendor-run sample. The Decoder’s coverage adds that Astra often describes actions more precisely even where Flora finds them better.
What does the $10 per GPU-hour assumption mean?
It is the rental price NVIDIA used to convert GPU time into dollars. If real prices or utilization differ, the cost per video hour changes in proportion. Our arithmetic shows that even at $40 per GPU-hour, the estimate would sit near $2.88, still about 31 times below the Astra figure.
Who can use Flora?
Because the suite is open source, any robotics team can download and run it. The estimate assumes data-center class GB300 GPUs, so small teams will likely rent cloud capacity. Check the repository’s license terms before building a commercial product on it.
Why is a robotics story on a gaming site?
The estimate hinges on GPU rental economics, and the same silicon market shapes graphics card supply and pricing for players. Flora itself is not a game or a console feature. It is an AI-infrastructure story that touches the hardware gamers care about.