VynarisEarly betaGet your API key

Blog · 2026-09-07 · Vynaris Team

GPT-6 Astra costs $0.99 per successful robot-arm bowl placement vs $5.30 for Claude Fable 5.1

RoboCurve’s 20-trial robot-arm test puts GPT-6 Astra at $0.99 per bowl success. Both models reached just 10% on precise puzzle insertion.

GPT-6 Astra cost $0.99 per successful bowl placement in RoboCurve's physical benchmark. Claude Fable 5.1 cost $5.30. That 5.4x lead vanished on precise puzzle insertion: both completed 2 of 20 trials, lifting their cost per success to $13.60 and $21.80.

Prices verified 2026-09-07 from OpenAI's live pricing page and Anthropic's live pricing page. The benchmark used Standard list rates of $10 input and $50 output per 1M tokens for both models.

TL;DR

Verdict

Task and model            Input / output per 1M  Successes  Cost/run  Cost/success  Expected min/success
------------------------  ---------------------  ---------  --------  ------------  --------------------
Bowl, GPT-6 Astra         $10 / $50              19/20      $0.94     $0.99         2.6
Bowl, Claude Fable 5.1    $10 / $50              8/20       $2.12     $5.30         17.0
Puzzle, GPT-6 Astra       $10 / $50              2/20       $1.36     $13.60        34.0
Puzzle, Claude Fable 5.1  $10 / $50              2/20       $2.18     $21.80        59.0

Pick Astra for this benchmark's bowl task. It was cheaper per run, completed 95% versus 40%, and finished each attempt faster. Do not read that as a general robotics win. On the puzzle, the models tied at a 10% completion rate. Neither result is deployment-grade evidence.

What RoboCurve actually tested

RoboCurve gave each model control of bimanual I2RT YAM arms. Each arm had six degrees of freedom and a parallel-jaw gripper. The agent observed three camera views plus proprioceptive state. It emitted absolute end-effector poses through a 20-call tool-calling budget.

The two instructions looked simple. One asked the robot to place a red block in a bowl. The other asked it to pick up a round puzzle piece by its center knob and fit it into a matching groove. Every model ran 20 trials per task at medium reasoning effort and a 25% speed cap.

A human operator scored the highest stage reached: approach, contact, lift, position, or final placement. That staged rubric matters. On the puzzle, Astra often reached the groove, then stalled before insertion. A high mean stage is not a completed task.

The cost-per-success math

The useful denominator is a finished physical outcome, not an API attempt. For each task-model cell:

cost per success = cost per run × 20 trials ÷ successful trials

For Astra's bowl runs, that is $0.94 × 20 / 19 = $0.9895, rounded to $0.99. For Fable, $2.12 × 20 / 8 = $5.30. Astra was 81.3% cheaper per successful bowl placement: 1 - $0.99 / $5.30.

The puzzle changes the bill. Astra spent $1.36 × 20 = $27.20 to produce two completions. Fable spent $2.18 × 20 = $43.60 for the same two. That makes Astra 37.6% cheaper per puzzle success, but both systems failed 90% of attempts.

Use the LLM cost calculator to replace the benchmark's list prices with your own token cost. Then divide the resulting cost per attempt by your measured completion rate. A cheap call with a 10% success rate is an expensive outcome.

API cost per successful robot-arm manipulation across two models and two tasks
Source: RoboCurve, 20 trials per model per task; prices verified 2026-09-07. API cost only.

Token efficiency helped until task difficulty took over

Astra used 2,100 output tokens per bowl run. Fable used 12,900, or 6.14x more. Astra also averaged 2.5 minutes per run against 6.8. Combining latency with completion rate gives an expected 2.6 minutes per successful Astra placement versus 17.0 for Fable.

On the puzzle, Astra still used fewer output tokens: 2,700 against 10,500, a 3.89x gap. It also ran faster, 3.4 minutes versus 5.9. Yet equal 10% completion rates pushed expected time per success to 34 and 59 minutes. The token advantage survived. The outcome advantage did not.

This is the counterweight to our earlier Astra price-break-even analysis. Fewer tokens can erase a higher sticker price. They cannot compensate for a capability ceiling at the final millimetre of a physical task.

Where routing changes the unit economics

Route by failure stage, not by prompt category. A cheaper or faster planner can handle approach, contact, and lift. Escalation only helps if another policy has evidence of completing the stage that fails. Here, both models reached the same puzzle bottleneck. Sending failed Astra insertions to Fable would add cost without a measured success gain.

A confidence-gated route could still work for bowl placement. The trigger could be repeated misses, poor grasp geometry, or failure to clear the table. But the route needs its own eval. RoboCurve did not test cascades, so this is an implementation hypothesis, not a benchmark result.

Hardware time also belongs in the decision. The reported dollars cover model inference only. They exclude robot depreciation, power, supervision, resets, damaged objects, and recovery. Our code-review cost-per-bug analysis could focus on tokens because retries were software. Physical retries occupy equipment and people.

The honest tradeoff: the sample is too small for a fleet decision

Twenty trials per cell produce wide uncertainty. The bowl comparison also used different rigs: Fable ran on rig 3, while Astra ran two days later on rig 1. Trials were not interleaved. Grading was operator-judged with the model visible. These choices do not invalidate the result, but they limit what it supports.

RoboCurve also disabled prompt caching for Anthropic. OpenAI automatically cached about one-fifth of Astra's input, but the benchmark did not apply that discount. The published Astra cost is therefore slightly conservative under the stated method. We cannot quantify the difference because the page does not publish exact cached-input counts.

The practical verdict is narrow. Astra dominated this bowl setup and reduced API cost per successful placement by 81.3%. On precise insertion, both policies hit the same 10% ceiling. Before routing real robot work, rerun the model routing test on the same rig, interleave trials, blind the grader, and include the hardware cost of every failed attempt.

One final buyer check: compare recovery economics, not only first-pass inference. A deployment with cheap failed attempts can still lose money when a person must reset the scene. Track API dollars, robot minutes, operator minutes, damaged inventory, and completed outcomes in the same ledger. That ledger prevents a model bargain from hiding a costly recovery loop on the factory floor.

Sources