GPT-6 Astra vs Claude Fable 5.1: AI Is Moving From Answering Questions to Doing the Work
OpenAI’s Astra wants to operate the computer and finish the workflow. Anthropic’s Fable 5.1 wants to stay with a hard project for hours.For the last few years, every major AI launch has produced the same conversation: which model scored higher, which one codes better, which one has the bigger…
OpenAI’s Astra wants to operate the computer and finish the workflow. Anthropic’s Fable 5.1 wants to stay with a hard project for hours.For the last few years, every major AI launch has produced the same conversation: which model scored higher, which one codes better, which one has the bigger context window, which one is “smarter.”After reading through what OpenAI and Anthropic are shipping with GPT-6 Astra and Claude Fable 5.1, I think that conversation is becoming less useful. The question that matters now is different:What kind of work can I actually hand over to the model?Earlier models produced something: an answer, an email, a SQL query, a function, a summary. These newer models are built to do something. Research across websites. Operate applications. Understand an entire repository. Write code, run it, inspect the result, find what went wrong, fix it, and keep going until there’s something close to a finished deliverable.Astra and Fable 5.1 are both moving hard in that direction, but from different angles. Astra feels like a model built to operate environments. Fable 5.1 feels like a model built to stay with difficult problems. There’s plenty of overlap — Astra is a serious coding model, and Fable can drive browsers and tools — but the way each company positions its model tells you a lot about where AI agents are going next.The two models side by sideBoth launched the same week. Both list the same headline API price. The specs are close enough that the numbers alone won’t help you choose.GPT-6 Astra — announced September 3, 2026API model ID: gpt-6-astraContext: 1M tokens · Max output: 128K tokens · Knowledge cutoff: April 2026Pricing: $10 / $50 per million input/output tokens; separate rates for cache reads and writesReasoning: effort levels from low to maxChatGPT: Plus, Pro, Business, Enterprise — staged rollout, no Free tierAPI: staged rollout; also Microsoft Azure and Amazon BedrockClaude Fable 5.1 — announced September 1, 2026API model ID: claude-fable-5-1Context: 1M tokens · Max output: 128K tokens · Knowledge cutoff: June 2026Pricing: $10 / $50 per million input/output tokens; $0.25 per million for cache readsReasoning: adaptive, effort defaults to highClaude: Pro, Max, Team, Enterprise — available now, no Free tierAPI: available now; also Amazon Bedrock, Google Cloud Vertex AI, and Microsoft FoundrySources: OpenAI’s Astra announcement and Anthropic’s Fable 5.1 announcement. Specs and availability are as of today — both rollouts are moving daily, so check the official pages for the current state.The interesting part isn’t in these specs. It’s what each company expects you to hand over.GPT-6 Astra: complete the workflowOpenAI describes Astra as its most capable model for difficult end-to-end work, with the biggest improvements in computer use, browser use, software engineering, science, cybersecurity, and professional knowledge work. The pitch is that Astra carries work across code, browsers, and professional software rather than returning an answer to the original prompt.Consider a request like this:Find me five good apartments near my office, compare commute time, rent, parking and reviews, and create a spreadsheet.A chatbot gives you search tips. A web-enabled model finds some listings. An agent like Astra is meant to open a browser, search several sites, read the listings, collect prices and details, check commute times, organize everything into a spreadsheet, and come back with a recommendation. The prompt stops being “tell me how to do this” and becomes “here’s the outcome I need, go work toward it.”Where Astra is strongestComputer use. This is Astra’s defining capability. Instead of needing a custom API integration for every piece of software, a computer-use model reads the interface — buttons, menus, forms, tables, dialogs — and interacts with it visually. OpenAI shows Astra filling out online forms, updating CRM records, organizing calendars, installing software, and troubleshooting what it sees on screen. A request like “take the customer list in this spreadsheet, check every company in our CRM, fill in missing industry data, flag accounts without an owner, and summarize when you’re done” is no longer text generation. It’s computer work.Browser automation. A huge amount of real work still happens through websites rather than clean APIs. Astra combines browsing with reasoning and persistence across many steps: search, open results, navigate, read the fine print, collect prices, compare, and return a structured answer. “Research flights from Chicago to Tokyo for these dates, compare one-stop and nonstop routes, check baggage policies, and put the best five in a table” is a realistic ask.Documents, slides, and spreadsheets. This may quietly become Astra’s biggest practical use case. OpenAI says it’s trained specifically for professional environments and can work from an existing template or style rather than starting from scratch. Give it last quarter’s deck, this quarter’s sales spreadsheet, meeting notes, and leadership comments, and ask for the Q3 business review in your existing structure with updated charts and the three biggest changes called out. That’s a much more valuable workflow than “write bullet points for a slide.”Software engineering and migrations. Astra is a strong coding model in its own right. The useful framing is a project, not a snippet: “Understand where this dependency is used across the repo, create a migration plan, update the affected modules incrementally, run tests after each stage, and don’t change unrelated behavior.”Beyond text. OpenAI also demonstrates Astra in Blender, Unreal Engine, game, and CAD-style workflows, and positions it strongly for science — combining reasoning with scientific software, data analysis, and plotting. Those environments require spatial reasoning and visual judgment on top of code, which is where computer use starts to matter outside the browser.Cybersecurity — with an asterisk. Astra is the first model OpenAI has designated as reaching the “critical” cybersecurity threshold under its preparedness framework, meaning it can find and exploit previously unknown vulnerabilities without step-by-step guidance. The public model refuses advanced offensive tasks; the looser safeguards are limited to vetted organizations through OpenAI’s trusted-access program. It’s a good reminder that what a model is technically capable of and what a product lets you do are not the same thing.A practical Astra example: plan an entire tripHere’s the request that makes the difference easiest to see:Plan a 10-day Alaska trip in September. Compare flights, research rental cars, find places to stay, build the day-by-day itinerary, estimate the budget, and create a spreadsheet I can use while traveling.A traditional model produces an itinerary. An Astra-style agent breaks the project into actual work:Research destinations → Search flights → Compare rental cars → Research hotels → Check driving distances → Build itinerary → Calculate costs → Create spreadsheet → Write the travel briefNone of those steps is hard on its own. What’s new is one system carrying the whole chain across a browser, a spreadsheet, and a document without you stitching the pieces together. That’s why computer use is such a big deal.Can you use Astra today?Astra is real and shipping, but it isn’t generally available yet. OpenAI is rolling it out in stages, starting with organizations in its Daybreak Access Program, with ChatGPT Plus, Pro, Business, and Enterprise access “in the coming days.” As of today, it has started reaching Pro, Business, and Enterprise accounts; Plus comes later.The rollout is cautious for a reason. OpenAI slowed Astra’s release in August after early evaluations suggested it would cross the “Critical” cybersecurity threshold under its Preparedness Framework, and confirmed that designation in its Path to Astra post on the eve of launch.It’s the first OpenAI model in that tier, so it ships with extra safeguards, including monitoring that can pause or stop a task it flags, even one unrelated to security. The launch also lands a few weeks after the Hugging Face incident in July, which put frontier-model containment under public scrutiny.The plan details are more nuanced than the announcement suggests, and OpenAI’s Help Center is the source of truth:In regular ChatGPT chat, Astra appears as GPT-6 Pro, rolling out to Pro ($100 and $200), Business, and Enterprise. It is not included with Plus in chat.In ChatGPT Work and Codex, all four plans get it as it rolls out. Pro and Business Premium seats can use their full existing allowance; Plus and Business Standard seats get limited Astra usage, with optional credits after that.Buying credits does not get you early access. Enterprise admins have to enable Astra for their workspace; it’s off by default. Codex needs CLI version 0.153.0 or newer.There is no Free-plan access, and Astra uses your allowance faster than GPT-5.6 Sol.For developers, the gpt-6-astra docs are public, but access is still staged by account, the API free tier isn't supported, and seeing the model ID in the documentation doesn't mean your project can call it yet. Microsoft has started rolling it out through a limited-access program on Foundry, and OpenAI says Amazon Bedrock follows as the rollout expands.Once you have access, a basic request looks like this:from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", reasoning={"effort": "high"}, input=""" Review this application architecture. Identify: - scalability bottlenecks - reliability risks - database issues - security concerns Then propose an incremental migration plan. """)print(response.output_text)Astra supports five reasoning levels — low, medium, high, xhigh, and max — so you can spend more compute on hard problems and less on simple ones.Claude Fable 5.1: stay with the problemAnthropic describes Fable 5.1 as its most capable model for coding and knowledge work, with an emphasis on demanding reasoning and long-horizon agentic tasks, projects that run for hours and span many applications. It can plan, use tools, recover when steps fail, provide progress updates, operate browsers, work through complex codebases, and run as a managed agent.One structural detail worth knowing: Fable 5.1 and Claude Mythos 5.1 are the same underlying model with different safeguards. Fable is generally available; Mythos is limited to trusted-access programs for cybersecurity and life-sciences work. It’s the same capability-versus-product distinction Astra has, just made explicit in the naming.The mental model is different from Astra’s. Instead of “operate these tools and complete this workflow,” Fable’s strongest pitch is:Here is a very difficult project. Understand it deeply and keep working until we have a result.Where Fable is strongestLarge-codebase engineering. Real features don’t live in one function. They touch the frontend, the API, auth, business logic, the database, background jobs, analytics, and tests. Anthropic specifically says Fable 5.1 is designed for features that span an entire codebase: “Add organization-level permissions to this application. First understand our current authorization model. Update the database, backend, frontend, and tests without breaking existing roles.” That’s much closer to software engineering than code generation.Long-running, self-verifying coding. Fable is built for sessions that continue for hours, and Anthropic explicitly says it writes its own tests and uses them to verify its work. The loop becomes: understand, plan, implement, write tests, run tests, inspect the failure, debug, change the implementation, run again, verify. That verification loop matters far more than producing more code.Root-cause debugging. One of Anthropic’s clearest messages is that Fable should fix the underlying problem rather than the visible symptom. A shallow fix for a flaky service is wrapping it in a retry. A real investigation asks whether the failure can be reproduced, which component failed, whether the input was invalid, whether there’s a race condition, whether a dependency broke, and whether a regression test can be written before the fix lands. That’s what Fable is positioned for.Code review. Instead of “is this code good?”, you can ask Fable to review a PR as the senior engineer responsible for the service — correctness, concurrency, error handling, database behavior, security, performance, backward compatibility, tests — and to skip style unless it affects maintainability. An agent that understands the surrounding repository rather than just the diff is valuable at scale.Performance optimization. Anthropic calls out performance work specifically. Take the classic N+1 pattern:for customer in customers: orders = db.execute( "SELECT * FROM orders WHERE customer_id = ?", customer.id )Any model recognizes this immediately. The agentic version is different: find everywhere the pattern occurs, inspect the schema, check available indexes, decide whether batching is safe, change the implementation, benchmark before and after, and run the tests. Spotting the problem is trivial. Fixing it safely across a real codebase is engineering.Design-to-code with visual checking. Fable uses vision to evaluate its own output: build the UI, run it, look at the rendered result, compare with the design, notice the differences, adjust, repeat. That’s more useful than generating SwiftUI from a screenshot once and hoping.Document-heavy work and deep research. Fable isn’t only about programming. Anthropic highlights its ability to read charts, diagrams, and tables inside PDFs, which opens finance, legal, and analytics workflows. Hand it a 200-page annual report, the earnings deck, and analyst notes, and ask it to find where management’s commentary is inconsistent with the numbers and show the evidence. Anthropic describes Fable as able to take large research projects and return review-ready deliverables with minimal oversight.A practical Fable example: hand it a real featureSuppose you have an iOS app and you say:Implement a shared-family packing system. Understand the existing data model before changing anything. Add the feature across persistence, business logic, and UI. Write tests, run the suite, investigate failures, and document any architectural changes.Fable’s ideal workflow looks like:Read repository → Understand architecture → Find affected systems → Design solution → Implement → Write tests → Run tests → Debug → Verify → Prepare final changesThe interesting part isn’t any single step; it’s that the model is expected to stay with the feature through the failures, not just produce a first draft and hand the debugging back to you. This is where “AI coding” starts turning into something closer to AI software engineering.Can you use Fable 5.1 today?Yes, and this is the biggest practical difference between the two launches. Fable 5.1 is generally available on every paid Claude plan (Pro, Max, Team, Enterprise) across web, mobile, desktop, Cowork, Claude Code, Claude Design, Claude for Microsoft 365, and Claude Tag.One pricing detail: availability doesn’t mean unlimited usage. On Max and eligible premium Team/Enterprise seats, some Fable usage is included within weekly limits. On Pro and standard Team seats, Fable 5.1 runs on pay-as-you-go usage credits from the start. Free users don’t have access.For developers, the model is live on the Claude API, Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry:from anthropic import Anthropicclient = Anthropic()message = client.messages.create( model="claude-fable-5-1", max_tokens=8192, messages=[{ "role": "user", "content": """ Review this software architecture. Identify the root cause of the reliability issue. Do not patch symptoms. Propose the smallest correct fix, describe how you would verify it, and specify the regression tests we should add. """ }])print(message.content[0].text)How I’d choose between themThe simplest test is how the task sounds when you say it out loud.If it sounds like “go do these things,” I’d reach for Astra. Computer use, browser workflows, documents, spreadsheets, slides, 3D and CAD, scientific tools, anything where the job is moving across several apps to produce a finished deliverable. A typical prompt: research these ten companies, collect their latest funding data, update my spreadsheet, create three charts, and prepare a five-slide deck. Astra’s one-line pitch is: operate the environment and complete the workflow.If it sounds like “figure this difficult thing out,” I’d reach for Fable 5.1. Large codebases, long-running coding sessions, debugging, root-cause analysis, code review, deep research, anything that needs sustained reasoning and verification. A typical prompt: our app randomly drops WebSocket connections after several hours; understand the system, reproduce the failure, find the root cause, fix it, and add tests so it can’t happen again. Fable’s one-line pitch is: stay with the hard project and engineer the solution.The overlap is large, so for anything important, test both on your actual task.A data engineering exampleThis is the one closest to my own work. Suppose a company has 130 Spark pipelines and wants to migrate to a new architecture. The request looks like:Understand all pipeline dependencies. Design a safe migration order. Rewrite the pipelines incrementally, compare old and new output, investigate discrepancies, and do not switch production until parity is confirmed.Any capable model can write the validation code:def validate_migration(old_df, new_df): assert old_df.count() == new_df.count() old_total = old_df.selectExpr("SUM(revenue) AS total").first()["total"] new_total = new_df.selectExpr("SUM(revenue) AS total").first()["total"] assert abs(old_total - new_total) < 0.01Writing the validation isn’t the hard part. The hard part is what happens when it fails:Run migration → Run validation → Validation fails → Investigate the difference → Find the transformation issue → Fix the pipeline → Run again → Confirm parityThat loop — not the code generation — is the difference between a coding assistant and a system that does the work. It’s a Fable-shaped problem because it needs sustained reasoning across a large codebase. But if the migration also required clicking through a vendor console, updating tickets, and producing a status deck, Astra’s computer use starts to matter. Most real projects have both halves.What matters more than benchmarksBoth models have impressive numbers. OpenAI says Astra saturates FrontierMath Tier 4 at roughly 98% and ARC-AGI-3 at 99.9%, with big gains over GPT-5.6 Sol on agentic coding and computer use. Anthropic says Fable 5.1 beats Fable 5, Opus 5, and Sol across a range of benchmarks.The detail I find most telling is buried in OpenAI’s own comparison table. Astra leads Fable 5.1 on most rows. But Fable 5.1 wins on Humanity’s Last Exam with tools (65.0% vs 57.2%) and on the Artificial Analysis Intelligence Index. And several Fable rows are simply blank, because its safeguards refused the questions.That table is a good illustration of the problem. Each company ran the other’s model, but under its own harness, settings, and safety configuration. Different evaluations use different tools, reasoning budgets, task sets, and retry policies. Anthropic itself notes that Fable’s safeguards can lower its scores because some requests get rerouted or restricted. So when you compare two agents, you’re really comparing model + tools + prompts + harness + environment + retries + verification — not model versus model.That’s why I wouldn’t pick either one based on a leaderboard. The question that actually matters is: which model succeeds most reliably on my workload? Give both the same ten real tasks. Track completion rate, time, manual corrections, cost, and quality. Ten runs on your own problems will tell you more than any benchmark.Cost per task, not cost per tokenAstra and Fable 5.1 have the same list price: $10 per million input tokens and $50 per million output tokens. That doesn’t mean they cost the same to use.Here’s why. Say Model A costs $3.50 per attempt but takes three tries to get a task right. That’s $10.50. Model B costs $5.00 and gets it right the first time. Model B is cheaper, and you haven’t counted the engineer’s time spent reviewing the two failed attempts.The one real pricing difference is cache reads. Fable 5.1 charges $0.25 per million tokens for context the model has already processed. That matters for agents that keep working against the same large repository or document set, because cached context ends up being most of the bill. Anthropic estimates the cut saves about 25% on typical workloads and more on agentic ones.So the number to track isn’t price per token. It’s cost per completed task.The model isn’t the whole agentIt’s easy to confuse a powerful model with a complete autonomous system. A real agent looks more like this: USER GOAL │ ▼ AI MODEL │ ┌───────────┼───────────┐ ▼ ▼ ▼ Browser Code Computer │ │ │ ▼ ▼ ▼ Search Terminal Apps │ │ │ └───────────┼───────────┘ ▼ RESULT │ ▼ VERIFICATION │ ┌───────┴───────┐ ▼ ▼ PASS FAIL │ │ ▼ ▼ FINISH ITERATEThe model is the reasoning engine. The agent also needs tools, permissions, authentication, memory, execution environments, error handling, logs, approval boundaries, and safety controls. That’s why the shift I care about most isn’t a benchmark delta. It’s the shape of the interaction:Before: Prompt → Model → AnswerNow: Goal → Plan → Act → Observe → Evaluate → Correct → Verify → DeliverWriting code is useful. Writing code, running it, watching the tests fail, understanding why, fixing the implementation, and verifying the result is much more useful. The same holds for building a UI and visually checking it against the design, or finding information and going back to the primary source when two claims disagree.The bigger shiftA few years ago we asked whether AI could answer a question. Then whether it could write code. Then whether it could use a tool. Now we’re asking whether we can hand it the entire task, and soon, how long we can safely let it work before checking in.Astra represents an AI that can move through the digital environment around it. Fable represents an AI that can stay engaged with a hard problem far longer than previous systems. Those directions will converge; a truly useful agent needs both. It has to understand the problem deeply, operate the necessary tools, remember what happened, recover when something fails, and — most importantly — verify its own work.We’re not at the point where every task should be delegated without supervision. These systems still make mistakes, and tool access, permissions, security, and human review all matter. But the direction is clear. The frontier is no longer about models that can answer. It’s about models that can work.What would you use them for?If you had Astra or Fable 5.1 today, what would you actually delegate? Something you currently spend hours clicking through? A bug your team has been stuck on for weeks? A pipeline migration nobody wants to touch?Tell me in the comments what you’re trying to build or automate, and which model you’d pick for it. I’ll pull the most interesting answers into a follow-up once I’ve had time to run both models on real tasks. Fable 5.1 is available now, and Astra should reach more accounts over the next few days.If this was useful, a few claps help it reach more people, and you can follow me here on Medium for the hands-on comparison when it’s ready.The most interesting experiments with these models won’t come from another benchmark. They’ll come from seeing how much real work we can trust them to finish.This story is published under the Generative AI publication. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories. Let’s shape the future of AI together!GPT-6 Astra vs Claude Fable 5.1: AI Is Moving From Answering Questions to Doing the Work was originally published in Generative AI on Medium, where people are continuing the conversation by highlighting and responding to this story.Source: Generative AI Pub — Published — Category: Image AI