Fable 5.1 vs GPT-6 Astra: Theo on Coding, Computer Use and Cost

Last week brought two models that genuinely matter for my workflow: Claude Fable 5.1 and GPT-6 Astra. Both are incredible, but they differ enough that a single winner misses what each one can do. I use Fable every day and see Astra as a huge leap; across the two I am using nearly a billion tokens a day, so I have encountered both strengths and surprising weaknesses.

I want to compare what the models are good and bad at, how efficiently they spend tokens and how quickly subscription limits hit. A recommendation without those details would hide how different their capabilities are.

Start with science. Anthropic highlighted Terminal-Bench Science 0.1: Fable 5 previously reached about 25% at $34, while 5.1 at extra-high reasoning reached about 50% for less. OpenAI's chart puts Astra on low at 54.3% and about $11, above the best Fable result at under a third of the cost. These are benchmark results, not a guarantee for every scientific task.

Both models made remarkable jumps in science and 3D, and I suspect shared training data or reinforcement-learning tools may play a role; that is speculation, not something I know. Astra's 3D leap is especially striking. Fable's Fish Slop submarine game already had recognizable fish, coral, lighting, a small economy and combat, and its movement felt surprisingly good.

Fable's first Fish Slop prototype has a submarine that can move among fish, feed them and participate in a small economy. I was impressed that the fish looked like fish, with eyes in the right place, and that the controls were enjoyable. That combination was already a strong result before I saw Astra's version.

Astra's version looks like a generational jump: the fish tank and environment are stunning. It is not an unqualified win, though. Its movement and core loop felt worse, and I had to ask it to fix performance. Other examples, including Blender scenes of Amazon's spheres and a furnished demo house, suggest Astra can help make useful 3D mockups rather than merely hypothetical demos.

I also saw Blender projects made with Astra, including a recreation of Amazon's spheres and Thomas Ricouard's demo house. The house has furniture and a credible background beyond the window. To me, the improvement resembles the earlier jump from autocomplete to agents that could complete tasks.

The distinction appears when you interact with the result. Fable handles camera movement, animations and other delicate game interactions much better in my experience. For my experiments I start the prototype with Astra to establish the look, then use Fable to clean up the details. Astra feels like a sledgehammer; Fable can apply changes more gently.

That graphical lead does not settle game development. When a cursor moves or a camera follows a mouse, small changes to animation curves and speed determine whether a game feels good. Those edges are where I still prefer Fable, even though Astra's visuals are ahead.

Computer use is another large Astra advantage. It is much faster than GPT-5.6 Sol, and improvements to Codex on macOS, not just the model, help it launch, gather context and work in the background. I have even set up another Mac mini for around-the-clock tasks. With my hand injured, being able to have an agent do some computer work faster than I could is especially useful.

Sol was good enough at computer use for me to start using it regularly for tedious tasks. With Astra I have scaled that up, though the gap is also partly about the Codex product and its integration. I do not think the benchmarks I have seen fully convey the difference in day-to-day use.

Both models also write more readable prose than their predecessors, even without special instructions. I still prefer the writing of the original non-thinking Kimi K2, despite its other limitations, and I rewrite much of the copy these models produce. Astra has a slight edge in prose and can critique Fable's copy, but its proposed rewrites still often fall short.

Astra can recognize problems in Fable's generated copy and suggest improvements, but I still often rewrite the result myself. For prose quality I give Astra a small lead; for useful product copy, that edge does not absolve either model from human editing.

Astra's irritating habit is filling interfaces with unnecessary subtitles. One version of Fish Slop had 21 of them before cleanup, with phrases like 'a little tank, a lot of life' scattered throughout. Better writing is not much help when the model insists on putting it everywhere; I do not trust it with UI work without careful supervision.

For audio and video, I have been disappointed by both, though I am unusually picky and others' experiences may differ. Ben Davis showed a useful exception: Astra's computer use can prepare a Final Cut project for a human editor, arranging the workspace rather than editing the video itself. That kind of setup could save work even if the creative edit remains in human hands.

Think of the video setup like an assistant opening the right files, terminal and development environment before a programmer starts. The assistant has not done the creative work, but it has prepared the room. Ben's example suggests Astra can make that preparation useful to an editor.

The current AI-edited videos I see remind me of a 2020 GPT-3 demo that generated a rudimentary React app. It was astonishing at the time, but a professional developer would not have shipped that app. Video editing may have its own leap eventually, yet I do not think either model is ready to automate professional editing today. Astra gets the edge in this category because of computer use.

The GPT-3 React demonstration looked remarkable when it appeared, yet its tiny application was far from what an experienced engineer needed for a real project. I see a similar gap between a flashy AI video-editing demo and an edit that meets a professional creator's standards.

On frontend design, Astra has improved substantially over Sol: it follows instructions better and can make less embarrassing landing pages. With enough iteration it can produce good design. Comparing sample pages, I see better animations and usable starting points, but still too much generic copy and too many unnecessary labels.

The comparison site I show includes Sol pages that are usable but filled with generic Tailwind-style layouts and decorative text. Astra's versions improve on those designs and add nice animations, yet some still have awkward cutoffs and repeated phrases. Turning on a design skill helps somewhat, but it does not remove the need for judgment.

Fable 5.1's one-shot designs impressed me more: the layout, animations and distinctive style look far less like an obvious template. Still, both models frustrate me when I iterate on existing design. I would rate neither above five out of ten for frontend work; Fable gets to a decent starting point with much less force than Astra.

A Fable 5.1 design looks much more custom to me than the equivalent Fable 5 result. I could plausibly encounter it online without immediately guessing it was generated in one shot. That makes Fable the stronger starting point, not a substitute for repeatedly checking and refining the design.

For full-stack understanding, both models now seem able to connect backend, frontend, clients and servers and make reasonable changes across a codebase. That was not true of the previous generation in my experience. Fable seems to understand the implications of a codebase faster, while Astra is more inclined to test assumptions repeatedly and grind toward an answer.

On the same large project, Fable may inspect the code, identify concerns and build around them. Astra may explore several possible approaches and stress-test each until it reaches a similar answer. Fable is quicker when its intuition is right; Astra's painstaking approach can uncover a deep bug Fable misses, but it can take much longer and use many more tokens.

The difference in approach is visible when Astra validates every edge and every assumption. Fable's quicker intuition makes ordinary changes pleasant, but Astra's relentless verification can find something deeper. The tradeoff is time and token consumption; I would call overall full-stack capability close.

That introduces a theme: Fable's performance feels steadier, whereas Astra has astonishing peaks and moments that make me question the subscription. Its persistence is especially useful for large rewrites. In a Rust port of TypeScript, Sol reached roughly 30% on the existing test suite; Astra passed 80% in about three days before stalling around 82.6%.

The Rust rewrite continued from roughly 30% test accuracy with Sol to more than 80% with Astra, then stalled at 82.6%. It went far beyond other models I had tried on the task, but the stalled result does not mean the port was complete or production-ready.

I gave that rewrite a goal and 40 subagents without staying in the loop. There is a major bias in my comparison: during OpenAI's early-access test my usage was not charged, and I ran 130 billion tokens. I have never had equivalent unlimited free access to Fable, so I could push Astra in ways I have not tested equally with its competitor.

I have also shipped some Astra-produced rewrites, including a Swift mobile version of T3 Code, and tried a Rust GPUI version. But big rewrites show a recurring problem. For my older Ping video collaboration app, I asked the model to plan a modernization, make a branch and implement it; it produced a result in about an hour and 20 minutes.

The free access matters to interpreting all of this. I was able to give Astra a very large budget during early access, while I have not had the same free unlimited opportunity with Fable. My comparison of extreme rewrites is therefore not a balanced head-to-head test.

Ping lets streamers bring guests into calls and embed them as layers in OBS. The original interface was carefully designed by our cofounder Bryn. The rewrite replaced the landing page and dashboard, obscured information, shifted the layout during joining and buried device selection behind extra steps. Those details matter to creators using a live production setup.

In the Ping rewrite, the problem was not just that the page looked different. The dashboard stopped conveying useful information, joining caused a layout shift, and previewing a selected camera required extra steps. For a streamer who embeds a guest into a production layout, those behaviors can matter as much as whether the app runs.

The worst part was the instruction it ignored: port features one at a time and reuse as much UI code as possible. The rewrite discarded the existing interface instead. This was not simply a compaction issue: I used a million-token context and have seen similar behavior outside the preview. I could add a paragraph insisting on pixel-perfect preservation, but I should not have to restate the request that way.

I have seen Astra disregard requests to preserve interface behavior in more than one rewrite, including a GPUI version of T3 Code that used an old-style sidebar. Explicit acceptance criteria may help, but I do not want to append an elaborate preservation paragraph to every request that already says to reuse the UI.

For mergeability, Fable 5.1 wins in my workflow. Counting follow-ups between a PR being filed and merged, I average about two for Fable and six for Astra. That reflects review bots finding issues and subsequent fixes in my projects; it is a personal measurement, not a controlled benchmark. Fable tends to submit code closer to ready and is better at landing focused changes without expanding the scope.

I do not mean Astra's code is unmergeable. My subjective chart puts it around or slightly above Fable 5, a big improvement from Sol, which I trusted mainly for exploratory or mechanically verifiable work. Fable 5.1 raises the bar again. The gap between Astra and Fable 5.1 is much smaller than the gap I saw between Sol and Fable 5.

My rough mergeability scores are a subjective illustration, not a formal measurement. Sol could eventually produce working code with enough feedback, while Fable 5 more often produced changes I would merge into a project used by hundreds of thousands of people. Astra has caught up to that earlier Fable standard, even if 5.1 is better still.

Astra is more thorough, writes more readable explanations and can produce elegant, appropriately scoped code, but it still often lets scope creep take over. For routine bug fixes, important UI changes or features, I default to Fable. When Astra is stuck in a loop, I sometimes give Fable the PR and ask it to discard what is unnecessary and land the useful change.

For a focused fix, Astra's explanations are more readable than Fable 5's old output, and its thoroughness can catch missed details. Fable 5.1 is nevertheless my preference when I need a clean PR to land. The right comparison is between the versions actually available, not between Astra and an older model alone.

Fable can also bloat a change after misleading review comments, but Astra does it more readily. Even after a request for minimal changes, review feedback can send it off course until a 50-line change becomes a thousand-line PR. Staying involved can mitigate the problem, yet Fable takes less effort to keep focused.

In game development, Astra makes more impressive 3D images while Fable better handles movement, camera response and animation curves. Neither independently makes a good game in my view, but combining them can support iteration. My prediction is that we will see a highly ranked indie game largely built with AI; that is a forecast, not evidence that the models can do it unaided today.

A pretty clip and a game that feels good are different tests. I expect model-generated components to become increasingly useful, but I would still combine and guide them rather than infer from a rendered scene that a complete game is good.

Understanding intent remains a serious weakness for Astra in my experience. After I merged roughly 150 AI-generated PRs with two regressions, both regressions came from Astra. One changed the automatically scrolling testimonials on the T3 Code marketing page into a manually scrolled grid during performance work. I asked it to find and revert the change and restore the animation.

The testimonial regression happened because a performance change replaced a continuously scrolling marquee with a static horizontal grid. I discovered it only when a later manual deployment of the marketing site exposed the change. My request was to revert whatever broke the effect, which was a behavior I explicitly wanted to keep.

Despite my repeated use of the word 'revert', Astra removed variables and listeners without restoring the auto-scroll. I also asked for a Tailscale development server so I could test remotely. It first launched the T3 Code application instead of the marketing site, then exposed the site with a host configuration that blocked the request.

The remote test mattered because I was working on another computer and wanted to inspect the change over Tailscale. A server for the main T3 Code application could not verify a marketing-page fix. When the model eventually launched the correct site, its host was rejected by the development server configuration.

It committed a machine-specific host allowance, later stopped the dev server while leaving the link pointed at the old port, and ultimately merged a PR without fixing the reported problem. I gave Fable essentially the same request, with the Tailscale instruction included upfront. About five minutes later it located the offending PR, restored the marquee and provided a working link.

Fable found the PR that changed the marquee and explained that the later paging timer was unnecessary for the performance goal. It restored the scrolling rows and gave me a working link. I did have to steer it past confusion caused by the earlier agent's PR, so the example is not a perfectly controlled test.

The comparison is not perfectly identical: I had to correct Fable when it worried about the other agent's merged and reverted PR, while the Tailscale request reached Astra as a later steering message. Even with that qualification, the Astra run was among my worst recent experiences. Its severe failures are rare, but they can be baffling; here I think it failed at basic agent work, not merely at guessing my intent.

I do not see these severe Astra failures on every run. The problem is that when they happen they can be so disconnected from the requested job that repeated feedback becomes exhausting. That variability matters to anyone deciding how much supervision a model needs.

Orchestration is where Astra stands out again. Fable can plan a sequence of subagents, but Astra can coordinate a swarm: agents work in parallel, exchange messages and send updates that cause the root agent to fan out further work. In my TypeScript rewrite I have seen it manage 40 parallel agents and keep their context moving. I think this opens up larger classes of problems, although my more dramatic expectations are speculative.

The orchestration pattern is not just starting several agents at once. Astra can receive their findings, send messages back, let agents communicate with one another and create more work as the investigation develops. I have watched that happen in the TypeScript rewrite, though running many agents also has a substantial cost.

Astra also handles steering while it is working. Older agents often abandoned the original tasks when I inserted a forgotten request; Fable 5.1 is better at this, and Astra appears better still. With a suitable harness, it can ask a question without blocking independent work, then incorporate the answer while working or resume after it finishes.

The nonblocking question feature depends on the surrounding app or harness. The model can ask which option a user prefers, continue independent work and later adapt when the answer arrives. I have seen this work in T3 Code; when I first tested the model without that support, a question could appear in its reasoning without a way for me to answer.

Astra is somewhat better at writing prompts for itself and other agents, though I still prefer prompts written by experienced developers. Neither model is reliable enough to write a chain of skills without review: letting one generated skill create another can rapidly amplify poor instructions. Write skills by hand or audit them carefully.

Using skills is different from writing them. In my experience Fable reliably selects a useful skill and follows it; Astra sometimes ignores one on subsequent turns. I suspect part of this comes from the Codex harness and its instructions rather than the model alone. Both can also miss boundaries or refusals; Fable feels more reliable to me, although neither is where I want it.

One failure I saw involved a PR-monitoring skill: after it had been loaded, the agent ignored it during later follow-ups. I learned that the Codex system instructions also govern when a skill applies across turns, so it is hard to attribute the behavior to the model alone. Fable has needed less attention to this in my workflow.

Cost cannot be judged from a single token price. At the time of recording, I said Fable 5.1's cache-read price had fallen from $1 to $0.25 per million, but cache reads were only a small share of my bill, while cache writes exceeded 60% of my Fable costs. OpenAI had also begun charging for cache writes. The proportions are specific to my workload and prices and limits can change.

A fourfold difference in cache-read prices sounds enormous, but its impact depends on how much of the bill consists of cache reads. For my Fable use that share fell from roughly 3% to 1%, while cache writes remained far more consequential. Another user's usage mix could produce a different result.

The important comparison is total cost per task and token efficiency. The Artificial Analysis index I showed listed Astra at $3.26 per task and Fable 5.1 at $7.60, despite similar nominal token pricing. It also showed Astra using roughly 27,000 tokens for work for which Fable used nearly 80,000. These figures describe that benchmark, not a universal ratio for every workload.

In the displayed Artificial Analysis comparison, the reported cost per task was $3.26 for Astra, about $5.86 for Opus 5 and $7.60 for Fable 5.1. My inference is that cheaper cache reads alone cannot explain the final bill; the number of tokens a model uses to complete work matters too.

OpenAI's flex API option can halve prices in exchange for uncertain throughput and delayed responses. That can be attractive for jobs that do not need an immediate answer. I would like a similar option for Codex because I often run work in the evening and can tolerate waiting.

Subscription limits make the comparison more complicated. In my estimate, the $200 Claude Code plan had around $8,000 of inference allocation and the $200 Codex plan around $12,000, but only half my Claude weekly allowance could be used for Fable. Those estimates and restrictions reflect my experience at the time, not a promise about current plans or other users.

My subscription estimates also depend on which model a plan lets me use. I described an effective Fable allowance of around half the estimated Claude allocation, versus an estimated full Codex allocation for Astra. That calculation comes from my own usage and contemporaneous limits, which may change.

I also found Claude's five-hour limits restrictive, while I said the higher Codex tiers had weekly limits without that five-hour cap. I use multiple accounts and much heavier workloads than most developers; fast and ultra modes can burn through allowances particularly quickly. On my use, Codex with Astra felt roughly four times as productive for the same subscription price, but that is an impression, not a measured general rule.

I use unusually demanding jobs, including large Rust rewrites with many subagents, to push these systems. Someone using a few hours a day and fewer agents may have a different experience. I specifically caution that fast mode and high reasoning settings can spend the available allowance quickly.

Codex resets had also been frequent during this period, sometimes returning allowance ahead of the ordinary weekly reset. I would not assume that cadence is guaranteed. Both frontier models remain expensive, and people on tighter budgets may be better served by waiting for comparable capability to reach cheaper options. My own usage amounts to tens of thousands of dollars of inference per month across plans.

I observed frequent discretionary Codex resets, including banked resets, and quoted another user's count of eight in 30 days. Those resets made my allocation stretch farther during this period, but I would not base a durable purchasing decision on them continuing.

My mental picture of quality is a steady high line for Fable and a much spikier line for Astra. Fable usually does what I expect, even if it sometimes disappoints. Astra can do things Fable cannot, then turn around and waste time in a loop or break a site. If unexpected failures derail your work and cost is less important, Fable's consistency may be worth paying for.

Astra's peaks can be extraordinary and its lows can involve a costly loop or a broken site. Fable's quality varies too, but in my experience it stays in a narrower band. I find Astra more stressful, and that operational cost is real even when its token bill is lower.

I like having both. If forced to choose one, I lean toward Astra because computer use and its other non-code capabilities help me beyond programming, particularly while my hand is injured. For someone who cannot justify the price, waiting or exploring available lower-cost options is reasonable; I expect comparable capabilities to become cheaper over time.

If cost is the main concern, my suggestion is to look for an eligible open-source program or wait for less expensive models. I mention GLM-5.3 Flash as a model I have found less prone to going off the rails on similar work. Those are individual experiences, not a guarantee for someone else's tasks.

My practical split is Fable for landing code and Astra for using my computer and other tasks. I estimate Fable produces mergeable code more often and has less severe low points, while Astra has broader capabilities and more dramatic highs. I also observed more security refusals from Astra in my use. Both have improved our productivity on T3 Code, and I find they complement each other rather than replace each other.

I do not think the coding gap is as enormous as the difference in my stress when something fails. Fable's more reliable code and Astra's broader capabilities both matter. My recommendation is to experiment with both when possible and use each where it contributes to the work.