Two frontier systems solving similar problems through different public interfaces, safeguards and product strategies
By this point, comparing Astra and Fable as a leaderboard contest would miss the most interesting lesson. Both models are built for difficult, long-running work. Both combine reasoning with tools, coding, vision and operational workflows. Both are surrounded by safeguards because their capability has moved into higher-consequence territory.
The useful comparison is not "Which model wins?" It is "Which engineering choices are visible, and what do those choices tell us about frontier AI system design?"
What Each Vendor Discloses, and What It Does Not
Neither OpenAI nor Anthropic publishes the complete internal architecture or training recipe, so this comparison works from documented product and API behavior and labels everything else with the evidence levels from the front matter.
OpenAI discloses a great deal about Astra as a deployed system: context and output size, knowledge cutoff, reasoning-effort controls, tool support, asynchronous tool calling, steering, compaction, persisted reasoning, computer use, safety evaluations and monitoring. Its system card also publishes unusually detailed evidence about cyber capability, alignment behavior and monitorability. Anthropic discloses that Fable 5.1 and Mythos 5.1 share the same underlying model, along with product positioning, pricing, long-running behavior, coding and vision capabilities, safety routing, data-retention policy and benchmark methodology, and publishes system cards describing capability and deployment decisions.
For both, the public sources used here do not justify claims about exact parameter count, complete internal architecture, mixture-of-experts or routing design inside the model, full training-data composition, the complete reinforcement-learning recipe, or the exact internal mechanism for persisted reasoning and long-running state. Those are Unknown for this edition, and they stay Unknown until a primary source changes that.
Positioning
OpenAI describes Astra as its most capable model for the hardest end-to-end work, including complex reasoning, coding, computer use, research and document creation. Anthropic describes Fable 5.1 as its most capable generally available model for coding and knowledge work, with particular emphasis on ambitious long-running and asynchronous projects. Both statements are Documented; both are also marketing, and the rest of this chapter is about what sits underneath them.
Reasoning Control
Astra exposes reasoning effort through API levels: low, medium, high, xhigh and max, and OpenAI allows developers to change the level during a conversation while preserving the cached prompt prefix. Fable 5.1 exposes the same five levels through an effort parameter on always-on adaptive thinking, defaulting to high, and Anthropic documents a per-message effort change that preserves the cache, in beta at the time of checking. Both are Documented.
This is the clearest point of convergence between the two systems: inference effort has become an explicit orchestration control with the same shape on both platforms. What either model does internally at a given level remains Unknown, and the vendors' guidance differs in emphasis, with Anthropic recommending that developers start at the default and step up or down against their own evaluations.
Context and Output
OpenAI publicly specifies Astra with a 1,050,000-token context window and up to 128,000 output tokens. Anthropic's model documentation specifies Fable 5.1 with a 1,000,000-token context window and up to 128,000 output tokens, billed at standard per-token rates across the whole window. The two systems are therefore close on headline capacity; the difference appears in how that capacity is priced.
Long-Running Work
Both systems are explicitly oriented toward work that extends beyond one response. Astra exposes several platform mechanisms that make this visible: async tool calling, mid-turn steering, persisted reasoning, compaction, multi-agent orchestration and subagent delegation. Fable 5.1 is described at the product level as able to plan work, use tools, recover when a step fails, operate across several applications and continue unattended for long periods.
The difference is partly one of public interface. OpenAI documents orchestration primitives directly in its API guide; Anthropic emphasizes end-to-end behavior across Claude products and the platform. Product behavior tells us what each system can do. It does not reveal how every internal mechanism is implemented, and the two vendors have chosen to expose different amounts of the machinery.
Tool and Computer Use
Astra's model page lists web search, file search, code interpreter, hosted shell, computer use, MCP, tool search and other tools as supported capabilities in the surrounding platform. Fable 5.1 is described as operating browsers, working through tools, running managed agents and using vision to inspect coding outputs. Both participate in the same shift: frontier models are designed to operate inside tool-rich systems rather than remain isolated text generators.
Self-Verification
Anthropic makes Fable's self-checking behavior unusually explicit: the company says Fable 5.1 can write its own tests and use vision to compare outputs against goals. OpenAI positions Astra for software work that includes building, operating and quality-checking applications, using different terminology. The underlying lesson is shared, and Chapter 13's warning applies equally to both: an iterative creation-and-verification loop is level one or two on the checking scale until something independent enters it.
Safeguard Strategy
Astra is OpenAI's first broadly deployed model to reach its Critical cybersecurity capability threshold. OpenAI describes strengthened isolation, checkpoint encryption, full-trajectory monitoring, blocking alignment evaluations and external deployment monitoring, and reports the monitorability concern discussed in Chapter 14.
Anthropic's strategy is visible in the Fable and Mythos split: the same underlying model, with Fable as the generally available version whose safeguards limit or route certain sensitive cyber, biology and chemistry requests, and Mythos restricted to vetted organizations through trusted-access programs. OpenAI's approach makes the monitoring layer visible; Anthropic's makes the access-control layer visible. Both are layer-four decisions in the five-layer lens, and neither tells us anything about layer one.
Cost
As of the sources checked for this edition, both Astra and Fable 5.1 list base API pricing of $10 per million input tokens and $50 per million output tokens. The similarity stops there. Astra lists cached input at $1 per million tokens and cache writes at $12.50 per million, and when a request's input exceeds 272,000 tokens the entire request is billed at long-context rates: twice the input and cache rates and one and a half times the output rate. Anthropic lists Fable 5.1 cache writes at $12.50 per million for a five-minute cache and $20 for a one-hour cache, cache reads at $0.25 per million, and no long-context premium anywhere in the window; Anthropic says the lower cache-read cost reduces typical and highly agentic workload expense relative to Fable 5.
A raw token price therefore does not tell us the cost of completing a task. Context length, caching, number of tool calls, reasoning behavior, retries and duration all matter, and the vendor that looks cheaper on the headline figure may not be cheaper on a week-long agentic job.
What the Interfaces Expose Differently
Both systems now expose reasoning effort as a first-class orchestration control, and both sit at roughly the same headline capacity and base price. The clearer difference is elsewhere in the public interfaces. OpenAI documents mechanisms such as asynchronous tool calling, mid-turn steering, persisted reasoning, compaction and explicit multi-agent orchestration around Astra. Anthropic documents per-message effort, adaptive thinking and long-running agent behavior around Fable 5.1, while presenting more of the sustained workflow through the broader Claude product and platform experience. These are differences in what the public interfaces expose, not evidence that the underlying models solve orchestration differently internally.
A Comparison That Matters More Than Benchmarks
Instead of asking which model scores one point higher, ask the questions that decide whether a frontier model becomes useful infrastructure: how much explicit control the developer receives, how the system recovers from long-running failure, how sensitive capability is restricted, what evidence can be preserved for verification, how expensive repeated context and agentic work becomes, how observable the system is when something goes wrong, and how easily capability can be integrated with existing software and organizational controls.
Every one of those questions has appeared as a chapter in this book. That is not an accident; they are the engineering problems, and the case studies are two answers to them.
Under the Hood
Rather than an operational loop, this chapter's mechanism is the comparison method itself: take each of the five layers and ask what is documented for each system there.
Underlying model capability. Both vendors publish benchmark results and capability claims. Neither publishes architecture, parameter count or training recipe. Documented at the level of results; Unknown at the level of mechanism, for both.
Post-training behavior. OpenAI describes advances in reinforcement learning and alignment and publishes alignment and monitorability evaluations. Anthropic describes model behavior and publishes system cards. Documented in broad method; Unknown in recipe.
Tools and harness. This is where the two diverge most visibly. Astra: Documented orchestration primitives in the API. Fable: Documented end-to-end behavior, with the orchestration mechanism not documented in the sources used here.
Safety and access controls. Astra: Documented trajectory monitoring, isolation and a capability-threshold classification. Fable: Documented safeguards, routing to Opus models without the sensitive-capability exposure, and the Mythos access split.
Product and API experience. Both Documented, including pricing, and both the layer most likely to change before this book's next edition.
A difference observed at layer five should not be attributed to layer one. Read the two columns and many apparent differences in intelligence turn out to be differences in product exposure, orchestration or safeguards.
Where It Can Still Fail
A product difference is read as a model difference. The interface exposes different controls, and the reader concludes the models differ in capability.
An undocumented mechanism is treated as absent. A public interface does not describe an internal or orchestration mechanism, and the reader concludes that the system cannot do it.
Headline price is treated as task cost. The cheaper token is the more expensive job.
A safeguard is read as a weakness. A refused or routed request is scored as a capability gap.
The comparison goes stale. Both columns are dated, and the reader forgets to check the date.
Astra and Fable are converging on many of the same capability goals while exposing different pieces of the system to developers and users. The frontier is becoming less about a single model number and more about the complete engineering stack that turns intelligence into sustained, controlled work, and the honest comparison is a comparison of stacks.
Three Things to Remember, One Thing to Do
1. Compare documented systems, not imagined hidden architectures.
2. Token price, benchmark score and context size each describe only one dimension of practical capability.
3. The most meaningful differences appear in orchestration, safeguards, verification and product exposure rather than in a simple intelligence ranking.
One thing to do. Take any two AI systems you are choosing between and answer the seven questions in "A Comparison That Matters More Than Benchmarks" for each. Beside every answer, write the layer it belongs to and whether it is Documented, Observed, Inference or Unknown. If more than half your answers are Unknown, you are not yet choosing between models; you are choosing between marketing pages.
How much do you need? Architect: Master · Platform/DevOps: Use · Security: Use. Everyone else: Know.