Special thanks to Uncanny Owl for providing access to both models through the ChatGPT Pro 20× and Claude Max 20× subscriptions used for this article.
I can give Astra and Fable 5.1 the same frontend brief and prefer either result. The more interesting difference appears when the work moves beyond the code editor.
I use GPT-6 Astra in Codex and Claude Fable 5.1 in Claude Code. Fable is strong at frontend design and coding. Astra is strong too, and sometimes produces the better first design. It can also deliver something so generic that I have to stop it and redirect the work.
My hands-on experience uses ChatGPT Pro 20× and Claude Max 20× subscriptions.
My strongest preference for Astra comes from computer use. Watching it work in Figma on this site changed what I was willing to hand over. That is my experience of these working setups, not a claim that one model wins every task.
Frontend design · Our Figma example · Benchmarks beyond one leaderboard · Mathematics · Costs · Productivity · My practical take
What I am comparing
These are field notes from actual work, supported by published evaluations. I have not run a controlled, repeated comparison for this article. I did not record a consistent reasoning setting, matched tool access, or a complete trial count across the sessions described here. I cannot turn those impressions into a reliable win rate.
| Question | What the evidence can tell us |
|---|---|
| Which first design do I prefer? | My judgment of the outputs I have seen. |
| Which coding agent scores better? | Results for a named benchmark, version, harness, and setting. |
| Can it operate a creative application? | The visible workflow and saved result, with scripts and integrations identified. |
| Which will need less guidance on my project? | Something to test on that project; the headline score cannot settle it. |
A good first design is not guaranteed
Fable 5.1 is a strong frontend design and coding tool in my work. With a fresh design brief, I sometimes prefer its composition and sometimes Astra’s. My experience gives me reasons to keep using both.
Astra’s disappointing results have often been too generic. A page can contain every requested section and still feel like a demo. It can have reasonable colors, rounded cards, and working buttons without a convincing hierarchy or any clear design judgment.
That is where “build me a premium website” becomes an inadequate brief. I care about the reading measure, the relationship between headings and body text, the spacing around a quote, and whether the controls feel like they belong to the same product. Those are decisions I still need to review.
The first result and the response to criticism are two different things. I want to know both. A beautiful opening attempt matters, but so does whether the agent understands a correction and carries it through the rest of the work.
This site is my clearest Figma example
The homepage of The Alignment began with a design process in Figma. I asked for pastel colors, a considered serif-and-sans pairing, and a complete page. I watched the work and steered it. The approved design was later implemented in WordPress.
It took iteration. I rejected designs that felt generic, asked for stronger project visuals, pushed back on oversized social controls, and changed the structure of the footer. The useful part was being able to direct work inside the design application and keep refining the same project.
That makes this a strong example of collaboration, not an untouched one-prompt result. My taste and feedback were part of the process. The finished site is evidence that we could get to a coherent result together; it is not a timed Figma comparison against Fable.
The later article-details card is a smaller example of the same design judgment. The first version relied on an outline and divider. I pushed for pastel surfaces against the white page instead. The result became calmer without changing the information it contained. That refinement happened in the WordPress theme, after the Figma work.
Different benchmarks, different answers
AA is one useful view. Vals AI, Arena, and Terminal-Bench’s published results ask different questions. Their scores should stay on separate scales.
| Evaluation and snapshot | Astra | Fable 5.1 | What it measures |
|---|---|---|---|
| Vals Index v2 September 5 | 66.61% | 68.83% | Finance, coding, and legal work, weighted by sector GDP. Fable has the higher aggregate. |
| Arena WebDev September 5 · max variants | 1,797 ±24 1,199 votes | 1,762 ±16 2,275 votes | Human preference on frontend tasks. The displayed ranges overlap; both have a rank spread of 1–2. |
| Terminal-Bench 4.0 Checked September 9 · max effort | 58.2% ±2.8 Codex | 57.9% ±3.8 Claude Code | Resolution rate across 66 terminal tasks. The 0.3-point gap is small relative to the displayed run-to-run variation. |
Vals adds a meaningful counterpoint. Its aggregate favors Fable, while Astra leads its terminal and code-migration evaluations. The sector weights reflect Vals’ chosen economic model; they are not a universal weighting of intelligence. The Fable report also discloses Opus 5 and Opus 4.8 fallbacks for refusals, so its reported results must be read with that setup attached.
Arena is closest to the design question. Its September 5 board puts Astra ahead, but the vote counts are still modest and the displayed ranges overlap. I would treat this as an early preference signal, not proof that Astra reliably produces better design or more maintainable code.
The terminal results need their own context. Snorkel, a Terminal-Bench task author and data partner, publishes the model-and-harness results above. They differ from AA’s run of Terminal-Bench 4.0 below. Different runs and agent setups should not be silently combined, and reusing a benchmark in several indexes does not create several independent task sets.
What Artificial Analysis adds
The results split by task. On AA’s September 3 Coding Agent Index, Fable 5.1 in Claude Code scores 70 and Astra in Codex scores 67. The separate Intelligence Index v4.3 places both at 53. These are different evaluations, not interchangeable scores.
Artificial Analysis published Intelligence Index v4.2 on September 4, then v4.3 on September 7. That is worth remembering before circulating a launch-week screenshot.
Version 4.2 added AA-Briefcase and GDP.pdf, removed GPQA Diamond, and changed grading and the weight of private tests. AA said these were interim steps toward v5. Fable 5.1 led that version. The changes deserve scrutiny, but their timing alone does not establish that they were made to favor a particular model.
| AA v4.3 measure | Astra — max | Fable 5.1 — max with fallback |
|---|---|---|
| Intelligence Index | 53 | 53 |
| Terminal-Bench 4.0 | 59.1% | 52.0% |
| AutomationBench-AA: workflows fully completed | 41.6% | 32.1% |
| Weighted average API cost per Index task | $3.26 | $7.63 |
Version 4.3 replaced two evaluations. Fable led AA-Briefcase and SciCode. The table reports full workflow completion, a different measure from partial-objective Score. Read AA’s results and methodology.
Artificial Analysis announces Intelligence Index v4.3 and explains the revised evaluations.
Read the original Artificial Analysis thread on X
I read those results as a reason to inspect the task breakdown. They do not give me a universal winner for frontend taste, maintenance work, or the next project in my queue.
Computer use is where my preference becomes stronger
My preference for Astra becomes much stronger when the work moves across applications. Figma is the clearest example I can document here. I have not run the same Figma project with Fable under matched conditions, so this supports my choice of workflow rather than a measured capability gap.
But several different mechanisms can produce a result inside an application. Clicking through its interface, calling an application API, and writing a script are all useful. They are not interchangeable evidence of GUI skill.
AutomationBench-AA, for example, involves simulated business applications and APIs. It is not a Figma or Blender mouse-and-keyboard test. Nor can I make a clean OSWorld comparison by combining vendor scores: Anthropic explicitly says its August 2026 task release is not directly comparable with earlier published OSWorld 2.0 results.
So my conclusion is deliberately personal: Astra in Codex has been the more compelling tool for the application work I have experienced. Establishing how much of that comes from the model, the harness, or its integrations would require a more controlled test.
A Blender example worth looking at
Chubby (@kimmonismus) shared a Futurama-style city made in Blender with GPT Astra and reported a 21-minute run. This is someone else’s demonstration, not my experiment. The post is useful because it shows a concrete creative result worth inspecting.
Modern city in the style of futurama in blender with GPT Astra. 21 minutes. Not bad at all
— Chubby♨️ (@kimmonismus) September 5, 2026
The caption does not establish the full prompt, the amount of human intervention, the use of scripts, or how Fable would have performed. I would not turn “21 minutes” into a comparative speed claim.
For a more documented workflow, OpenAI’s architectural-visualization example describes editable Blender geometry built through Python, background rendering, and computer-use inspection of the scene. It is a vendor demonstration, but it makes the combination of methods explicit. The interesting result is an editable project that can be inspected and revised.
What the AGI claims tell us
Jensen Huang wrote “AGI has arrived” about Astra. Greg Brockman told reporters, “Welcome to the AGI era,” according to Axios.
“AGI has arrived.”
— Jensen Huang Read the original post on X
Those statements explain some of the attention around the release. They are not comparative evidence about these two products, and they do not settle the definition of AGI. The research results below are more useful when we identify what was achieved and which system achieved it.
This is a snapshot as of September 9, 2026.
The mathematics is impressive. The model names matter.
A theorem, a formalization, and a benchmark score answer different questions. A new proof can add mathematical knowledge. A formalization translates an argument into statements a proof checker can verify. A benchmark tests performance under a specified protocol. All three matter, but combining them into one “math winner” hides the most useful details.
A matched test: FrontierMath Erdős
Epoch AI’s FrontierMath Erdős provides a particularly useful comparison. A pre-release Astra solved two of 68 selected open problems; Fable 5.1 solved none. Each model received one attempt per problem, with a $300 budget and 72-hour limit. Success required a verified Lean proof or disproof.
Astra found a counterexample to problem 74 for $218 in 15 hours and proved problem 126 for $247 in 16 hours. This is evidence in Astra’s favor on that protocol. It is an instructive contrast with Vals, whose weighted professional-task aggregate favors Fable: the evaluations test different abilities, so their results need not point to the same model. It is also a reminder of the remaining difficulty: 66 problems were not solved by Astra. The model was a pre-release version, and this curated set does not represent all of mathematics.
Claude: formalizing Fermat’s Last Theorem
Anthropic reports an 11-day effort that produced a complete Lean formalization of Fermat’s Last Theorem: about 13 million lines of code and six billion output tokens. The team used Prove2Me and a Claude Code-based multi-agent harness, with occasional high-level human direction.
The model was an internal research model roughly comparable to Fable 5.1. The achievement was formal verification of an existing mathematical argument, building on Wiles and substantial community work; it was not the first discovery of Fermat’s proof. The public proof repository includes verification instructions. I have not independently rebuilt it.
Anthropic’s original announcement of the Fermat formalization
Claude also produced new mathematics
Formalization is not the whole Claude story. In its August 10 research report, Anthropic described an unreleased Claude model improving a Riemann-related lower bound from 41.6% to 67.2%, using 31 million output tokens. This concerns the proportion of nontrivial zeta zeros on the critical line. It does not prove the Riemann hypothesis. Anthropic links the paper, expert notes, and formalization.
Navier–Stokes: a larger system, with Astra in a different role
The Polymarket post circulating on September 8 describes an OpenAI swarm solving Navier–Stokes. The primary announcement makes an essential distinction: the discovery used an internal model that OpenAI describes as substantially more capable than Astra. Astra then handled Lean formalization and verification over an additional 17 hours.
OpenAI reports roughly 10,000 concurrent agents in the successful group, 88 hours to the result, and approximately 130 billion output tokens on Navier–Stokes. It claims a finite-time singularity with smooth forcing, corresponding to the C/D formulations of the prize problem. That is a research-scale system with human coordination, not a single public Astra session.
The announcement links a Lean artifact and discusses concurrent work and priority. I am reporting the lab’s result, not certifying the proof or resolving the credit dispute. It belongs in the wider story of progress, but would be misleading as a win credited to the public Astra model.
The lesson across these projects is that the surrounding system matters. Model version, budget, shared state, tools, human direction, and a way to verify the result are part of the achievement. Those details should travel with the headline.
The token price is only the first line of the bill
Both public models list the same standard base API prices: $10 per million uncached input tokens and $50 per million output tokens. Their caching and long-context rules differ. The table below is in USD, checked September 9; it is not a prediction of how many tokens your task will need.
| Standard API rate, per 1M tokens | GPT-6 Astra | Claude Fable 5.1 |
|---|---|---|
| Uncached input | $10 | $10 |
| Output | $50 | $50 |
| Cached input reads | $1 | $0.25 |
| Cache writes | $12.50 | $12.50 for 5 minutes; $20 for 1 hour |
Astra’s pricing notes specify that prompts above 272K input tokens multiply input and cache rates by two and output rates by 1.5 for the full request. Fast mode doubles the applicable rates; Batch and Flex halve Standard rates. Fable’s reference lists its cache durations and a 50% Batch discount.
A simple illustration: 100,000 uncached input tokens plus 20,000 billed output tokens costs $2 on either model at base Standard rates. That excludes tools, taxes, retries, and any additional billable tokens. It holds the token counts equal for arithmetic; it does not assume the models use equal tokens on the same task.
In a real agent session, the total depends on how long it thinks, how much context it reuses, how often it retries, and whether the work succeeds. The API-cost row in the benchmark table is one measured workload mix. It is more informative than sticker price, but still not my monthly bill.
Codex and Claude Code subscriptions work differently
I have access to ChatGPT Pro 20× and Claude Max 20×. Each “20×” refers to its provider’s own baseline allowance; it does not mean the two plans provide equal tokens or agent runtime.
OpenAI lists Astra within the Codex allowance on its $100 and $200 Pro plans, with limited Astra usage on Plus and additional credits available. These are usage allowances, not unlimited agent runtime.
Anthropic’s plan guidance says Fable 5.1 is included on Max and eligible premium seats, up to 50% of weekly usage limits. On Pro and standard Team seats, it uses paid usage credits from the start. Those rules also apply in Claude Code. Similar monthly subscription prices therefore do not imply equivalent Fable and Astra access.
In my own use, OpenAI’s plan has felt more generous. I have especially appreciated the extra usage resets I have received. That is part of the value for me, alongside the model’s capabilities; it is my experience, not a promise that resets will always be available.
For my work, the useful cost is the cost of an accepted result: the model bill plus the time I spend prompting, reviewing, repairing, and waiting. An inexpensive run that leaves an hour of cleanup can be the expensive choice. I have not collected matched billing and time logs, so I cannot claim a personal cost winner.
What productivity research adds
A benchmark tests the agent. A productivity study asks what happens to the person using it. That distinction matters when the person still has to read the diff, judge the design, and decide whether the job is done.
METR’s February 2026 update is instructive. Its early-2025 experiment found that experienced open-source developers took 19% longer on tasks in repositories they knew well when AI was allowed. Its later experiment suggested speedups, but METR warned that selection effects and time measurement made the estimate unreliable: some developers and tasks were missing because participants did not want to work without AI. Neither result is a measurement of Astra versus Fable 5.1.
More recently, OpenAI’s September 6 internal study described increased agent use, coding, and experimentation, while acknowledging other changing factors. Over half of successful tasks estimated at four to eight human hours involved at least one intervention. That is useful observational evidence about collaboration inside a lab, not a randomized estimate of everyone’s productivity.
My own experience fits the need to count the whole workflow. I can be impressed by how much an agent accomplishes and still spend meaningful time directing it. A fair evaluation should record both the useful work it adds and the attention it consumes.
What I would choose today
| The work | My practical take |
|---|---|
| A fresh frontend design | Keep both in consideration. Judge the composition and how well each handles criticism. |
| Figma and creative application work | Astra in Codex is my stronger personal preference. This site is the concrete example. |
| Repository coding | Inspect the task breakdown and test on your repo. AA’s agent index and the Vals aggregate favor Fable; other results favor Astra. |
| Research mathematics | Use the exact model and verification setup the work requires. Internal lab results do not promise the same result in a consumer session. |
| A long or costly agent run | Compare accepted work per dollar and per hour of your attention, including retries and review. |
For a comparison on your own project, give both agents the same starting files, tools, and written brief. Save the first outputs before steering. Record the model, harness, reasoning setting, elapsed time, token bill, and every correction. Judge working behavior and editability alongside the screenshot. Repeat the exercise before treating one good attempt as a pattern.
My daily driver is Astra in Codex. I use computer tools a lot, and the ability to work inside actual applications is a large part of what I need from an agent. That makes Astra the better fit for my day-to-day work. Fable remains a strong design and coding tool in my workflow; my preference reflects the work I do, not a claim that Astra wins every comparison.
Sources and disclosure
Evidence cutoff: September 9, 2026 (Asia/Manila). The benchmark figures belong to their named versions and dates. My observations describe Astra in Codex and Fable 5.1 in Claude Code; they are not results from a controlled benchmark. Astra, one of the systems discussed here, assisted with research, writing, and graphics. The descriptions of my experience come from me. Published benchmark results were not rerun for this article, and I have not independently verified the research proofs.
Vals Index v2 · Arena WebDev · Terminal-Bench 4.0 · AA v4.2 changes · AA v4.3 results · AA’s launch analysis · Coding Agent methodology · Anthropic’s evaluation notes · OpenAI’s Blender workflow