GPT-6 Astra scored 95% on a robot-arm control task in an independent benchmark from Robocurve, up sharply from Claude Fable 5.1's 40% on the same task — while using 6.2x fewer output tokens and costing 2.3x less. The result comes from a public X thread by Jay Chooi, who runs Robocurve, a YC-backed benefit corporation focused on benchmarking robots. It's a real-time-control efficiency story more than a raw-capability one: on harder, precision-limited tasks, the two models tie.
This lands right after GPT-6 Astra's broader benchmark rollout, and it's a useful data point for anyone tracking whether large language models are closing in on genuinely real-time embodied control — a domain where token-generation speed, not just task accuracy, has historically been the binding constraint.
Update — September 11, 2026: Wenli Xiao posted a physical in-context learning demo: drop a human task video into Codex, and Astra drives a robot arm the same way on the first pass — reading the video trajectory (not a world model), with the harness doing IK, cameras at ~30Hz, and GPT-6 queried less often than the camera rate. Details and embed below. Broader hardware context: OpenAI's confirmed humanoid-robot intent.
TL;DR
| Question | Short answer |
|---|---|
| What was tested? | Robot-arm control via end-effector pose commands, passed through an automatic IK solver |
| Astra's score | 95% success on the primary task |
| Fable 5.1's score | 40% success on the same task |
| Token efficiency | Astra used 6.2x fewer output tokens |
| Cost | Astra was 2.3x cheaper per task |
| Harder precision tasks | Both models tied at 2/20 — Astra still 3.9x fewer tokens, 1.6x cheaper |
| Source | Jay Chooi (@chooi_jeq), Robocurve — a public X thread, not a published paper |
| Real-time control projection | Possibly by end of 2026, or 2029 under a conservative trend line |
| Physical ICL demo (Sept 11)? | Wenli Xiao: human task video → Codex → Astra drives arm same way first pass; trajectory from video, harness IK, cams ~30Hz |
What the benchmark actually tested
Robocurve's setup had both models control robot arms by specifying a target end-effector pose — essentially, where the gripper should end up — which was then passed through an automatic inverse kinematics (IK) solver to compute the actual joint angles needed to get there. That's an important methodological detail: neither model was asked to compute joint-level robotics math directly. The task tests planning and sequencing — deciding what pose to target next, based on the current state of the arm and task — not the geometry of robot arm movement itself.
On that task, GPT-6 Astra hit 95% success, compared to Claude Fable 5.1's 40%. That's a large gap on the primary benchmark. But Chooi's thread includes an important caveat that changes the read on the result: on harder tasks that demand more precision, the two models perform identically — both succeeding on just 2 of 20 trials. Astra still wins on efficiency there too, using 3.9x fewer output tokens at 1.6x lower cost — but the success-rate gap disappears entirely once the task gets hard enough.
Why this is a latency story, not an intelligence story
Put those two results together and the picture that emerges isn't "Astra is dramatically smarter at robotics than Fable 5.1" — it's "Astra reaches a comparable ceiling using a fraction of the tokens." On the easier primary task, that efficiency gap translates directly into a large success-rate gap, plausibly because a model generating 6x more tokens per decision has more opportunity to drift, second-guess, or simply take longer to converge on a workable plan within whatever time or step budget the benchmark enforced. On the harder task, both models hit a genuine capability ceiling regardless of token budget, and the efficiency gap shows up only in cost and speed, not success rate.
That distinction matters for anyone deciding which model to build robotics or embodied-agent workflows on top of. A model that's dramatically more token-efficient at reaching the same ceiling is the more practical choice for anything resembling a real-time control loop, even if its raw ability to solve genuinely hard precision tasks is no better than a competitor's.
The real-time control argument
Chooi's thread makes a broader claim worth taking at face value as a projection, not a fact: if LLM output token speed keeps increasing at 2-7x per year — with some frontier-class models reportedly doubling output speed monthly — then LLMs could plausibly control robot arms in real time by the end of 2026, or by 2029 under a slower, more conservative trend line.
The logic is straightforward. Real-time control requires a decision loop fast enough to keep pace with a changing physical environment — a robot arm that's mid-grasp can't wait several seconds for its controlling model to finish generating a token sequence before adjusting. Every reduction in tokens-per-decision, combined with every increase in raw generation speed, shortens that loop. Astra's 6.2x token reduction on the primary task is exactly the kind of improvement that argument depends on repeating, model generation after model generation, for the "real-time by 2026-2029" timeline to hold.
Whether that specific timeline pans out is genuinely uncertain — extrapolating a hardware-and-training trend two or three years forward is a bet, not a measurement — but the direction (fewer tokens per control decision, faster raw generation) has been consistent across recent model generations, and this benchmark is a fresh, concrete data point in that direction rather than a new hypothesis.
September 11: Wenli Xiao's physical in-context learning demo
A few days after the Robocurve numbers above, Wenli Xiao posted a demo that answers a different question than "which model scores higher on a fixed harness": can GPT-6 Astra imitate a human task from a video, on a physical robot arm, without a world model?
Per the thread: drop a video of a human doing the task into Codex; Astra then drives the robot arm the same way on the first pass. The model is reading a video trajectory — not building or querying a world model of the scene. The harness handles inverse kinematics (same IK pattern as the Robocurve setup above: the LLM targets poses / high-level motion; the stack converts that into joint commands). Cameras run at roughly 30Hz; GPT-6 is queried less often than the camera rate, which is exactly the latency pattern the token-efficiency argument in this post is about — the model does not need to emit a full control decision on every camera frame if the harness can hold a trajectory between queries.
That demo sits next to OpenAI's broader robotics intent — Altman confirming OpenAI will build a humanoid — as a near-term signal that general-purpose models plus a thin control harness can already do useful physical imitation, even before a dedicated humanoid product ships. Treat it as a practitioner demo (one researcher, one arm, one thread), not a published multi-trial benchmark like Robocurve's percentages above.
What people are asking
Is this the same "robot control" as a humanoid robot walking or manipulating objects in the real world? Not necessarily — the thread describes an arm-control task using end-effector pose commands through an IK solver, which is a common simulation or lab setup for testing planning and decision-making, not necessarily a full physical deployment. It's a meaningful proxy for control-loop capability, but treat "robot control benchmark" as testing decision quality and speed under a specific harness, not a claim about deployed humanoid robots in the field.
Why does GPT-6 Astra do so much better on the easy task but tie on the hard one? The likely explanation, based on what's disclosed in the thread, is that the easy task has enough slack that token efficiency alone determines whether a model converges on a working plan within budget, while the hard task exceeds both models' actual planning capability regardless of how many tokens they're given — a capability ceiling that efficiency gains can't buy past.
How does this compare to Mistral's Robostral or other embodied-navigation models? Robostral Navigate is a purpose-built navigation model trained specifically for map-less robot movement using a single camera, versus general-purpose frontier LLMs like Astra and Fable 5.1 being adapted to a control task via pose commands and an external IK solver. The comparison isn't apples-to-apples — a specialized model built for one physical task and a general-purpose LLM repurposed for planning are different bets, and this benchmark says more about frontier-LLM efficiency trends than about how either compares to purpose-built robotics models.
Should this change which model I build a robotics agent on top of? If your workload resembles this benchmark's shape — pose-level planning through an external solver, with real-time responsiveness mattering — the token-efficiency gap is a legitimate signal favoring Astra for that specific pattern. If your task looks more like the harder precision benchmark, the tie suggests model choice matters less than solving the actual planning bottleneck both models hit.
Related reading on explainx.ai
- OpenAI Confirms It Will Build a Humanoid Robot — the hardware-intent backdrop for physical demos like Wenli Xiao's
- GPT-6 Astra + Curv back-pain wearable demo (Sep 9, 2026) — embodied loop from spine tape to biomechanical PT, same Astra week
- Anthropic AI GDP scenarios + thijs's Astra painting demo (Sep 9, 2026) — macro model excludes robots the same week Astra controlled a real arm
- Claude Fable 5.1 and Mythos 5.1: Benchmarks, Pricing, and Safeguards — background on the model GPT-6 Astra is being compared against here
- Yann LeCun: LLMs, Physical Agents, and the Moravec Paradox — why physical-world tasks have historically resisted LLM approaches
- Mistral Robostral Navigate: Map-Less Robot Navigation — a purpose-built alternative to general-purpose LLM control
- NVIDIA MotionBricks: Real-Time Motion From Characters to Unitree G1 — another recent real-time robotics motion result
- World Humanoid Robot Games: Complete Guide — broader context on humanoid robot benchmarking
- GPT-6 Astra Robot Arms Reportedly Beat Fable 5.1 19-to-8, One Commentator Says — a follow-up covering a newer, separate Robocurve claim on real YAM hardware, plus an EEBench gap and an unrelated nested-simulation anecdote
- GPT-6 Astra Attempted 97% of Harmful Robot Tasks in RoboHarm — the safety side of this same robot-control interface: a reported benchmark testing whether Astra attempts harmful tasks rather than just completing them capably
Update — September 7, 2026: A separate commentator's report relayed a related Robocurve claim on real hardware — full coverage here.
Update — September 20, 2026: A reported RoboHarm safety benchmark found GPT-6 Astra attempted 97% of harmful tasks when placed in a robot-control role — full coverage here.
Primary sources: Jay Chooi (@chooi_jeq) on X · Robocurve · Wenli Xiao physical ICL demo on X
This post is based on a public X thread from Robocurve's Jay Chooi as of September 5-6, 2026, with a September 11 update for Wenli Xiao's physical in-context learning demo. The Robocurve benchmark's task suite, trial counts, and scoring methodology are described only in that thread and have not been independently replicated or published as a paper; treat the specific percentages as one group's reported results. The Wenli Xiao demo is a single researcher demonstration, not a multi-trial published study.