Author’s note: A closer look at Claude Fable 5.2’s 64.9% on RoboDojo Sim: under what conditions it achieved that score, how it compares with Opus 5.5 and GPT-6 Astra, what it doesn’t prove, and the costs and limitations to weigh before integrating it.
Here’s the bottom line. On RoboDojo Sim, run internally by Anthropic at the highest effort setting, Claude Fable 5.2 scored 64.9%, Opus 5.5 scored 39.4%, GPT-6 Astra scored 29.8%, and Fable 5.1 scored 27.6%. These results come from a model viewing camera images and controlling simulated dual arms—not from deployments in factories.
This isn’t a “the age of robotics is here” hype piece. We’ll separate simulation scores, demo videos, and real-world deployments. If you’re preparing to connect an API and work out the costs, this article will help you decide whether that 64.9% is enough to justify changing your technical approach.
The key takeaway: Understand what Fable 5.2’s 64.9% does and doesn’t prove, and which model you can call today for early-stage testing.
What Does Claude Fable 5.2’s 64.9% Actually Mean?
You can sum it up in three sentences. RoboDojo is a public benchmark that tests whether a model can control a dual-arm robot in a simulated environment based on camera images. A footnote in Anthropic’s announcement says the 64.9% result came from an internal run using the highest available effort level. As of 2026-11-10, we couldn’t verify the same score on RoboDojo’s public leaderboard, so it shouldn’t be described as “No. 1 on the public leaderboard,” let alone “the world’s most powerful robotics model.”
Here’s the RoboDojo Sim comparison from Anthropic’s announcement on 2026-11-09:
| Model | RoboDojo Sim | Gap vs. Fable 5.2 | Notes |
|---|---|---|---|
| Claude Fable 5.2 | 64.9% | — | Internal run, highest effort level |
| Claude Opus 5.5 | 39.4% | 25.5 points lower | From the same table |
| GPT-6 Astra | 29.8% | 35.1 points lower | Run by Anthropic, not self-reported by OpenAI |
| Claude Fable 5.1 | 27.6% | 37.3 points lower | Previous generation |
| Gemini 4 Carbon | Blank in the table | Not comparable | No score listed; don’t treat it as zero |
The score more than doubles from 27.6% to 64.9%, a striking jump across the table. But it comes with three caveats: a simulated environment, an internal run, and the highest effort level. Change any one of those—for example, switch to a physical robot, use a third-party evaluation, or run at the default effort level—and you can’t directly carry over this score.
What’s the Relationship Between Fable 5.2 and Mythos 5.2?
The announcement is clear: Claude Fable 5.2 and Claude Mythos 5.2 are the same underlying model. Fable has stronger cybersecurity and biosafety safeguards, so it’s available to all users. Mythos is only available to organizations that pass verification under life sciences or cybersecurity programs. Mythos isn’t “another, more powerful model”; for robotics evaluations, Fable 5.2 is the one to look at.
The official model IDs are:
- Claude API, Google Cloud, Microsoft Foundry, Claude Platform on AWS:
claude-fable-5-2 - Amazon Bedrock:
anthropic.claude-fable-5-2 - The corresponding Mythos IDs are
claude-mythos-5-2andanthropic.claude-mythos-5-2
Fable 5.2’s Core Robot-Control Capabilities: What’s in the Demo
The launch post says Fable 5.2 is significantly better than earlier Claude models at controlling physical robots, including on tasks it wasn’t specifically trained for. The accompanying demo video shows three scenarios: solving a Rubik’s Cube, unscrewing a bottle cap, and drawing a picture of a robot.
These should be understood as “demos from the launch post.” They show that the model completed these actions in specific setups, but they don’t tell us the success rate, how many retries were needed, or how often it failed. Nor do they mean Anthropic has released a ready-to-install robot skills package. The claim that some tasks weren’t specifically trained for is worth noting, but it’s still Anthropic’s own account, without independently reproducible data.
The launch post also says Fable 5.2 outperformed other frontier models on the same test suite, as well as most systems designed specifically for robot control. No list of those systems is provided, so readers can’t tell which systems or versions were compared. Treat this as a directional signal, not a definitive conclusion.
The Model Outputs Text; an External Suite Handles Control
This is the part that’s easiest to miss in a demo video. The model page specifies that Fable 5.2 takes text and images as input and outputs only text. It doesn’t issue motor commands directly. At every step, an external suite parses the text into actions, then sends a new camera image back to the model.
So, in real-world settings, control performance depends half on the model and half on your suite: how the action space is defined, what happens when parsing fails, and whether the latency per step is acceptable. RoboDojo’s 64.9% was achieved using Anthropic’s own suite. We don’t yet know how the score would change with a different suite.
Fable 5.2 Benchmarks: The Gap in Robotics Isn’t the Same as the Gap in Computer Use
When people hear “Fable 5.2 is very capable,” they sometimes lump its robotics scores together with results from other benchmarks. The table below uses data from Anthropic’s announcement on 2026-11-09 to compare the size of the gaps across several tests related to “control”:
| Benchmark | Fable 5.2 | Opus 5.5 | GPT-6 Astra | Fable 5.2 lead over Opus 5.5 |
|---|---|---|---|---|
| RoboDojo Sim (simulated bimanual tasks) | 64.9% | 39.4% | 29.8% | 25.5 points |
| OSWorld 2.1 (computer use, offline subset) | 89.3% | 87.2% | 79.5% | 2.1 points |
| AutomationBench | 51.4% | 42.5% | 41.4% | 8.9 points (Carbon scored higher at 53.9%) |
| Remote Labor Index (High tier) | 41.3% | 21.3% | 20.8% | 20.0 points |
On OSWorld 2.1, Fable 5.2 leads Opus 5.5 by just 2.1 points. That’s nowhere near the gap on RoboDojo, where scores range from 39.4% to 64.9%. If you need an agent for computer-use tasks, the difference between Opus 5.5 and Fable 5.2 is much smaller than it is on robotics benchmarks.
Effort Levels: 64.9% Isn’t the Default Setting’s Score
Unless otherwise noted, the scores in the announcement use each model’s highest available effort level at the time. Fable 5.2 defaults to high effort in the Claude API, but to Medium in the Claude app and Claude Code. So if you call the model with the default settings, you may not get the configuration that produced the 64.9% score.
The highest effort level means longer reasoning and more tokens. In a robotics loop that requires repeated decisions, using the highest level for every step can significantly increase latency and cost. The announcement doesn’t say how much the 64.9% score would drop at the high or medium effort level.
Specs Compared: Fable 5.2, Opus 5.5, and GPT-6 Astra
| Item | Claude Fable 5.2 | Claude Opus 5.5 | GPT-6 Astra |
|---|---|---|---|
| Context window | 1M | 1M | 1,050,000 |
| Maximum output | 128K | 128K | 128,000 |
| Input / output modalities | Text + images / text | Text + images / text | Text + images / text |
| Default API effort level | high | medium | Supports low to max |
| Latency tier | Moderate | Moderate | The official page doesn’t use the same scale |
| Knowledge cutoff | June 2026 | 2026-06 | 2026-04-30 |
All three models output text, a shared constraint you can’t avoid when using them for robot control.
What Fable 5.2’s Robot Score Doesn’t Cover
Three Electronic Devices Are a Hardware Design Experiment
The announcement also describes an experiment where Fable 5.2 was given a one-sentence prompt to design three working electronic devices: a home voice assistant, a USB speakerphone, and a handheld virtual pet. The project was completed in collaboration with Diode. Each circuit board took less than a day to produce, and all three devices worked without any circuit modifications.
This demonstrates hardware design capability, not anything related to RoboDojo. The devices themselves aren’t robots, either. Putting this alongside the 64.9% score can give the impression that Fable 5.2 can handle everything from design to control, but the two achievements are unrelated.
Fable 5.2’s Limits: Constraints That Affect the Control Loop
The following details come from the model page and update notes. Each one directly affects how you build your control loop:
- Forced tool calls return an error: Setting
tool_choicetoanyortoolreturns a 400. If your setup depends on “always call the action tool,” you’ll need to let the model choose for itself and add a parsing fallback. - Sampling parameters can’t be set: Passing
temperature,top_p, ortop_kreturns a 400. - Thinking can’t be turned off: Adaptive thinking is always on; you can only adjust the amount of thinking through effort. The update notes say that at medium effort or higher, telling the model “don’t think, just answer” in the prompt won’t stop it from thinking.
- It may say very little during long tool chains: When calling tools in sequence, the model may produce very little user-facing output, or call tools without explaining what it’s doing. Don’t rely on it to proactively report progress in your monitoring interface.
- It may stop early: Sometimes it ends a turn with a to-do list, or gets stuck on an ordinary obstacle. This is more common at low effort.
- Refusals still use quota: A refusal returns HTTP 200 with
stop_reasonset torefusal, and still counts toward your rate limit. - Data retention: Data is retained for 30 days. Zero data retention isn’t available unless Anthropic explicitly authorizes it.
Robot control loops have strict requirements: every step needs to produce an executable action. Taken together, the limitations above mean you’ll need to design for timeouts, empty actions, refusals, and mid-task stops as recoverable states before connecting the model to a control loop.
Fable 5.2 Pricing: Run the Numbers Before You Integrate
Official prices are per million tokens, based on the model pages, release notes, and quick mode page:
| Billing item | Fable 5.2 | Opus 5.5 | GPT-6 Astra (short context) |
|---|---|---|---|
| Standard input / output | $8 / $40 | $4 / $20 | $10 / $50 |
| Cache reads | $0.20 | $0.20 | $1 (cached input) |
| Cache writes | 5 minutes: $10; 1 hour: $16 | Listed on the official page, not included here | $12.5 |
| Batch | Half the standard price: $4 / $20 | Also half the standard price | Not listed here |
| Quick mode | $16 / $80 | $8 / $40 | — |
A few other things to keep in mind: Fable 5.2 is 20% cheaper than Fable 5.1 ($10 / $50). Quick mode offers the same capabilities, with output speeds up to 2.5 times faster than standard mode. However, the official pricing doesn’t list cache prices for quick mode separately. Based on the price multiplier, cache reads would cost about $0.40, 5-minute cache writes about $20, and 1-hour cache writes about $32. Prompt caches aren’t shared between speed modes, so switching from quick mode back to standard mode will result in cache misses. For GPT-6 Astra, once input exceeds 272K tokens, the entire request is billed at 2× the input rate and 1.5× the output rate.
In a robot loop, each step sends a new image, while the system prompt and action instructions remain mostly unchanged. This structure is a good fit for caching to reduce costs, but the image input and thinking tokens at each step can’t be avoided.
Can You Use Fable 5.2 Yet? APIYI Availability
As of 2026-11-10, neither claude-fable-5-2 nor any Mythos model appears in APIYI’s model catalog or public pricing API. We’ll launch this model as soon as possible. Check the platform’s model list for the available model IDs and prices. Until it’s listed, this article won’t provide a price for Fable 5.2 on APIYI or estimate the official price using a group multiplier.
The following related models were available in APIYI’s catalog that day. Prices are listed in USD per million tokens:
| Model ID | Input / Output | Cache reads | Endpoints | Best for |
|---|---|---|---|---|
claude-opus-5-5, claude-opus-5-5-thinking |
$4 / $20 | $0.2 | chat, messages | Getting a tool-calling and computer-use loop up and running |
claude-fable-5-1, claude-fable-5-1-thinking |
$10 / $50 | $0.25 | chat, messages | Comparing against the previous-generation baseline |
claude-fable-5, claude-fable-5-thinking |
$10 / $50 | $1 | chat, messages | Historical version comparisons |
gpt-6-astra |
$10 / $50 | $1 | responses (primary), chat | Cross-provider comparisons |
The prices in the catalog are listed rates; actual charges also depend on the token-tier multiplier. Check your bill for the final amount. The footnote for gpt-6-astra only specifies input pricing tiers: $10 for up to 272,000 tokens and $20 for 272,001 to 1,050,000 tokens. It doesn’t list the output price for long-context requests, so check your console bill. To connect, use the OpenAI-compatible API and set base_url to https://api.apiyi.com/v1.
A practical approach is to use claude-opus-5-5 first to get image input, action parsing, and failure recovery working, then switch the model ID to Fable 5.2 for comparison once it’s available on APIYI. The gap on the robotics benchmark (25.5 points) is much larger than on computer use (2.1 points), so waiting for Fable 5.2 makes sense—but demo videos alone aren’t enough to make a decision.
Fable 5.2: Strengths and Limitations in Robotics
Strengths
- A big leap over the previous generation: RoboDojo Sim improved from 27.6% to 64.9%, one of the biggest gains on the entire scorecard.
- A clear lead over comparable models: It scored 25.5 points higher than Opus 5.5 and 35.1 points higher than GPT-6 Astra, according to Anthropic’s announcement.
- Lower pricing: The standard price is 20% lower than 5.1, and cached input costs $0.20.
- Consistent visual input support: It accepts images and has a 1M context window, which can accommodate long histories of multi-step visual interactions.
Limitations
- Limited evidence: The results come from internal runs at the highest effort level. The public leaderboard doesn’t confirm the same score, and there’s been no independent replication.
- Simulation data only: The demo videos don’t report success rates, and the claim that it “outperforms most specialized robotics systems” doesn’t include a list of systems.
- Several constraints in the loop: It only outputs text, can’t be forced to call tools, can’t have its reasoning turned off, and rarely explains itself proactively during long sequences.
- High cost at the top setting: The score is based on the highest effort level. You’ll need to measure latency and token usage yourself for your actual deployment.
When not to switch models based on this
If you don’t have your own simulation environment or real-world robot loop, the 64.9% score isn’t verifiable for your use case—you can’t confirm whether it holds in your setup. And if your needs involve cybersecurity, biology, or everyday coding, this score doesn’t prove much; you should look at the relevant benchmarks instead. Anthropic’s own recommendation is to start with Opus 5.5 for most coding and knowledge work, then move up or down based on the difficulty.
Frequently Asked Questions
Q1: Is Fable 5.2’s 64.9% a score from the public leaderboard?
No. A footnote in the announcement says the result came from an internal Anthropic run. RoboDojo itself is a public benchmark, but as of 2026-11-10, we couldn’t verify the same score on its public leaderboard.
Q2: Was the 64.9% score achieved at the default effort level?
No. It was achieved at the highest available effort level. The default for the Claude API is high, while the defaults for the Claude app and Claude Code are Medium. The announcement doesn’t say what score Fable 5.2 gets at the default effort level.
Q3: Did Fable 5.2 outperform purpose-built robotics systems?
The announcement says it outperformed “most systems specifically designed to control robots,” but doesn’t include a list. We don’t know exactly which systems it outperformed.
Q4: Why is there no score for Gemini 4 Carbon on RoboDojo?
The announcement’s table leaves this cell blank and doesn’t explain why. A blank doesn’t mean a score of 0, and it’s not enough to draw conclusions about the model’s performance.
Q5: How can I prepare to use the API?
As of 2026-11-10, APIYI (apiyi.com) hasn’t listed `claude-fable-5-2` yet. We’ll make this model available as soon as possible; check the platform’s model list for the model name and pricing. In the meantime, you can use the available `claude-opus-5-5` to test the image input and tool-calling workflow, then switch models and compare results once Fable 5.2 is available.
Q6: Do the three electronic devices prove it can control robots?
No. The voice assistant, USB speakerphone, and virtual pet are hardware design experiments created in collaboration with Diode. They demonstrate circuit-design capabilities and have nothing to do with the dual-arm control score on RoboDojo.
Q7: Do computer-use agents need to wait for Fable 5.2?
Probably not. On OSWorld 2.1, Fable 5.2 scored 89.3%, compared with 87.2% for Opus 5.5—a difference of just 2.1 percentage points. Meanwhile, Opus 5.5’s standard price is half that of Fable 5.2.
Fable 5.2 Robotics Capabilities: Key Takeaways
- What the score means: 64.9% is the result on a simulated dual-arm task, run internally at the highest effort level.
- Size of the gap: 25.5 percentage points higher than Opus 5.5 and 35.1 points higher than GPT-6 Astra.
- A point of comparison: It leads by just 2.1 points on OSWorld. The two gaps shouldn’t be conflated.
- What the demos show: Solving a Rubik’s Cube, opening a bottle, and drawing are demos from the announcement, not production-ready skills.
- Loop constraints: It only outputs text; forcing
tool_choicereturns a 400 error, and thinking can’t be disabled. - Availability: As of 2026-11-10, Fable 5.2 isn’t available on APIYI. You can use
claude-opus-5-5to build your loop in the meantime.
Summary
Claude Fable 5.2’s progress in robotic control is a real and visible signal: RoboDojo Sim improved from 27.6% for the previous generation to 64.9%, putting it well ahead in Anthropic’s comparison. But this score applies to a narrow set of conditions: a simulated environment, internal runs, and the highest effort level. It doesn’t include real-robot success rates or indicate readiness for factory deployment.
If you already have a simulation or real-robot loop, it’s worth running a comparison with Fable 5.2 once it’s available. Be sure to account for its constraints in advance: text-only output, tools that can’t be forced, and thinking that can’t be disabled. If you don’t have a loop—or you’re working on coding or computer-use tasks—there’s no need to change your current approach because of this 64.9% score.
Author: APIYI Technical Team
Technical inquiries: Get in touch with us on the APIYI homepage at apiyi.com. Check the platform’s model list for availability updates.
